From 237f392cc1a022ab710e388cc877e02cbcbfdd56 Mon Sep 17 00:00:00 2001 From: Sebastian Ullrich Date: Fri, 14 Jun 2024 12:35:45 +0200 Subject: [PATCH] chore: update stage0 --- stage0/src/CMakeLists.txt | 23 +- stage0/src/lake/README.md | 450 + stage0/src/lakefile.toml.in | 43 + stage0/src/stdlib.make.in | 4 +- stage0/stdlib/Init/Data/Array/Basic.c | 2 +- stage0/stdlib/Init/Data/Array/Lemmas.c | 2 +- stage0/stdlib/Init/Data/BitVec/Basic.c | 2 +- stage0/stdlib/Init/Data/Char/Lemmas.c | 21 + stage0/stdlib/Init/Data/Fin/Basic.c | 2 +- stage0/stdlib/Init/Data/List/Basic.c | 2 +- stage0/stdlib/Init/Data/String/Basic.c | 36 +- stage0/stdlib/Init/Data/String/Extra.c | 8 +- stage0/stdlib/Init/Meta.c | 2 +- stage0/stdlib/Init/Prelude.c | 94 +- stage0/stdlib/Init/System/FilePath.c | 8 +- stage0/stdlib/Lake.c | 53 + stage0/stdlib/Lake/Build.c | 53 + stage0/stdlib/Lake/Build/Actions.c | 5095 ++ stage0/stdlib/Lake/Build/Basic.c | 741 + stage0/stdlib/Lake/Build/Common.c | 25092 ++++++++ stage0/stdlib/Lake/Build/Data.c | 2339 + stage0/stdlib/Lake/Build/Executable.c | 3211 + stage0/stdlib/Lake/Build/Facets.c | 1187 + stage0/stdlib/Lake/Build/Fetch.c | 6927 +++ stage0/stdlib/Lake/Build/Imports.c | 8713 +++ stage0/stdlib/Lake/Build/Index.c | 4483 ++ stage0/stdlib/Lake/Build/Info.c | 1724 + stage0/stdlib/Lake/Build/Job.c | 25371 ++++++++ stage0/stdlib/Lake/Build/Key.c | 1484 + stage0/stdlib/Lake/Build/Library.c | 8977 +++ stage0/stdlib/Lake/Build/Module.c | 34041 +++++++++++ stage0/stdlib/Lake/Build/Package.c | 30527 ++++++++++ stage0/stdlib/Lake/Build/Run.c | 12151 ++++ stage0/stdlib/Lake/Build/Store.c | 590 + stage0/stdlib/Lake/Build/Targets.c | 3364 ++ stage0/stdlib/Lake/Build/Topological.c | 415 + stage0/stdlib/Lake/Build/Trace.c | 3189 + stage0/stdlib/Lake/CLI.c | 33 + stage0/stdlib/Lake/CLI/Actions.c | 3210 + stage0/stdlib/Lake/CLI/Build.c | 4734 ++ stage0/stdlib/Lake/CLI/Error.c | 4608 ++ stage0/stdlib/Lake/CLI/Help.c | 1231 + stage0/stdlib/Lake/CLI/Init.c | 6422 ++ stage0/stdlib/Lake/CLI/Main.c | 49258 ++++++++++++++++ stage0/stdlib/Lake/CLI/Serve.c | 1953 + stage0/stdlib/Lake/CLI/Translate.c | 1699 + stage0/stdlib/Lake/CLI/Translate/Lean.c | 9409 +++ stage0/stdlib/Lake/CLI/Translate/Toml.c | 5264 ++ stage0/stdlib/Lake/Config.c | 33 + stage0/stdlib/Lake/Config/Context.c | 73 + stage0/stdlib/Lake/Config/Defaults.c | 314 + stage0/stdlib/Lake/Config/Dependency.c | 620 + stage0/stdlib/Lake/Config/Env.c | 1449 + stage0/stdlib/Lake/Config/ExternLib.c | 253 + stage0/stdlib/Lake/Config/ExternLibConfig.c | 156 + stage0/stdlib/Lake/Config/FacetConfig.c | 300 + stage0/stdlib/Lake/Config/Glob.c | 1610 + stage0/stdlib/Lake/Config/InstallPath.c | 4974 ++ stage0/stdlib/Lake/Config/Lang.c | 609 + stage0/stdlib/Lake/Config/LeanConfig.c | 4209 ++ stage0/stdlib/Lake/Config/LeanExe.c | 1197 + stage0/stdlib/Lake/Config/LeanExeConfig.c | 356 + stage0/stdlib/Lake/Config/LeanLib.c | 1027 + stage0/stdlib/Lake/Config/LeanLibConfig.c | 904 + stage0/stdlib/Lake/Config/Module.c | 3274 + stage0/stdlib/Lake/Config/Monad.c | 2032 + stage0/stdlib/Lake/Config/Opaque.c | 71 + stage0/stdlib/Lake/Config/Package.c | 2482 + stage0/stdlib/Lake/Config/Script.c | 151 + stage0/stdlib/Lake/Config/TargetConfig.c | 626 + stage0/stdlib/Lake/Config/Workspace.c | 12126 ++++ stage0/stdlib/Lake/Config/WorkspaceConfig.c | 334 + stage0/stdlib/Lake/DSL.c | 65 + stage0/stdlib/Lake/DSL/Attributes.c | 1435 + stage0/stdlib/Lake/DSL/AttributesCore.c | 2079 + stage0/stdlib/Lake/DSL/Config.c | 1814 + stage0/stdlib/Lake/DSL/DeclUtil.c | 12223 ++++ stage0/stdlib/Lake/DSL/Extensions.c | 80 + stage0/stdlib/Lake/DSL/Meta.c | 3504 ++ stage0/stdlib/Lake/DSL/Package.c | 3814 ++ stage0/stdlib/Lake/DSL/Require.c | 3816 ++ stage0/stdlib/Lake/DSL/Script.c | 2981 + stage0/stdlib/Lake/DSL/Targets.c | 10246 ++++ stage0/stdlib/Lake/Load.c | 33 + stage0/stdlib/Lake/Load/Config.c | 175 + stage0/stdlib/Lake/Load/Lean.c | 1129 + stage0/stdlib/Lake/Load/Lean/Elab.c | 13975 +++++ stage0/stdlib/Lake/Load/Lean/Eval.c | 23883 ++++++++ stage0/stdlib/Lake/Load/Manifest.c | 9048 +++ stage0/stdlib/Lake/Load/Materialize.c | 3302 ++ stage0/stdlib/Lake/Load/Package.c | 1748 + stage0/stdlib/Lake/Load/Resolve.c | 22268 +++++++ stage0/stdlib/Lake/Load/Toml.c | 21535 +++++++ stage0/stdlib/Lake/Load/Workspace.c | 1175 + stage0/stdlib/Lake/Main.c | 104 + stage0/stdlib/Lake/Toml.c | 33 + stage0/stdlib/Lake/Toml/Data.c | 33 + stage0/stdlib/Lake/Toml/Data/DateTime.c | 5924 ++ stage0/stdlib/Lake/Toml/Data/Dict.c | 1890 + stage0/stdlib/Lake/Toml/Data/Value.c | 2565 + stage0/stdlib/Lake/Toml/Decode.c | 3908 ++ stage0/stdlib/Lake/Toml/Elab.c | 33 + stage0/stdlib/Lake/Toml/Elab/Expression.c | 9265 +++ stage0/stdlib/Lake/Toml/Elab/Value.c | 7405 +++ stage0/stdlib/Lake/Toml/Encode.c | 586 + stage0/stdlib/Lake/Toml/Grammar.c | 10242 ++++ stage0/stdlib/Lake/Toml/Load.c | 1084 + stage0/stdlib/Lake/Toml/ParserUtil.c | 2857 + stage0/stdlib/Lake/Util/Binder.c | 2408 + stage0/stdlib/Lake/Util/Casing.c | 257 + stage0/stdlib/Lake/Util/Cli.c | 1913 + stage0/stdlib/Lake/Util/Compare.c | 687 + stage0/stdlib/Lake/Util/Cycle.c | 623 + stage0/stdlib/Lake/Util/DRBMap.c | 2066 + stage0/stdlib/Lake/Util/EStateT.c | 2581 + stage0/stdlib/Lake/Util/EquipT.c | 738 + stage0/stdlib/Lake/Util/Error.c | 231 + stage0/stdlib/Lake/Util/Exit.c | 106 + stage0/stdlib/Lake/Util/Family.c | 2457 + stage0/stdlib/Lake/Util/FilePath.c | 253 + stage0/stdlib/Lake/Util/Git.c | 1952 + stage0/stdlib/Lake/Util/IO.c | 57 + stage0/stdlib/Lake/Util/JsonObject.c | 807 + stage0/stdlib/Lake/Util/Lift.c | 469 + stage0/stdlib/Lake/Util/List.c | 201 + stage0/stdlib/Lake/Util/Lock.c | 553 + stage0/stdlib/Lake/Util/Log.c | 9325 +++ stage0/stdlib/Lake/Util/MainM.c | 1495 + stage0/stdlib/Lake/Util/Message.c | 845 + stage0/stdlib/Lake/Util/Name.c | 1092 + stage0/stdlib/Lake/Util/NativeLib.c | 468 + stage0/stdlib/Lake/Util/Opaque.c | 3869 ++ stage0/stdlib/Lake/Util/OrdHashSet.c | 1368 + stage0/stdlib/Lake/Util/OrderedTagAttribute.c | 1913 + stage0/stdlib/Lake/Util/Proc.c | 2386 + stage0/stdlib/Lake/Util/RBArray.c | 1272 + stage0/stdlib/Lake/Util/Store.c | 281 + stage0/stdlib/Lake/Util/StoreInsts.c | 524 + stage0/stdlib/Lake/Util/Sugar.c | 708 + stage0/stdlib/Lake/Util/Task.c | 375 + stage0/stdlib/Lake/Util/Version.c | 4607 ++ stage0/stdlib/Lake/Version.c | 533 + stage0/stdlib/Lean/Attributes.c | 92 +- stage0/stdlib/Lean/Class.c | 94 +- stage0/stdlib/Lean/Compiler/CSimpAttr.c | 92 +- stage0/stdlib/Lean/Compiler/IR/Borrow.c | 184 +- .../Lean/Compiler/IR/ElimDeadBranches.c | 94 +- stage0/stdlib/Lean/Compiler/IR/EmitLLVM.c | 186 +- stage0/stdlib/Lean/Compiler/IR/EmitUtil.c | 184 +- .../Lean/Compiler/IR/ExpandResetReuse.c | 92 +- stage0/stdlib/Lean/Compiler/LCNF/Check.c | 92 +- stage0/stdlib/Lean/Compiler/LCNF/CompilerM.c | 92 +- stage0/stdlib/Lean/Compiler/LCNF/ElimDead.c | 92 +- .../Lean/Compiler/LCNF/ElimDeadBranches.c | 94 +- .../stdlib/Lean/Compiler/LCNF/FixedParams.c | 110 +- stage0/stdlib/Lean/Compiler/LCNF/FloatLetIn.c | 186 +- stage0/stdlib/Lean/Compiler/LCNF/JoinPoints.c | 514 +- stage0/stdlib/Lean/Compiler/LCNF/LCtx.c | 492 +- stage0/stdlib/Lean/Compiler/LCNF/Level.c | 92 +- .../Lean/Compiler/LCNF/Simp/ConstantFold.c | 92 +- .../Lean/Compiler/LCNF/Simp/FunDeclInfo.c | 166 +- stage0/stdlib/Lean/Compiler/LCNF/ToLCNF.c | 186 +- stage0/stdlib/Lean/Compiler/Specialize.c | 186 +- stage0/stdlib/Lean/CoreM.c | 2 +- stage0/stdlib/Lean/Data/HashMap.c | 458 +- stage0/stdlib/Lean/Data/HashSet.c | 172 +- stage0/stdlib/Lean/Data/Lsp/Capabilities.c | 26 +- stage0/stdlib/Lean/Data/Lsp/CodeActions.c | 10 +- stage0/stdlib/Lean/Data/Lsp/Diagnostics.c | 6 +- stage0/stdlib/Lean/Data/Lsp/InitShutdown.c | 8 +- stage0/stdlib/Lean/Data/Lsp/Internal.c | 92 +- stage0/stdlib/Lean/Data/Name.c | 201 + stage0/stdlib/Lean/Data/NameMap.c | 184 +- stage0/stdlib/Lean/Elab/Command.c | 5050 +- stage0/stdlib/Lean/Elab/DeclNameGen.c | 92 +- stage0/stdlib/Lean/Elab/Frontend.c | 227 +- stage0/stdlib/Lean/Elab/GuardMsgs.c | 368 +- stage0/stdlib/Lean/Elab/Inductive.c | 8 +- stage0/stdlib/Lean/Elab/Match.c | 92 +- stage0/stdlib/Lean/Elab/MutualDef.c | 28 +- stage0/stdlib/Lean/Elab/PreDefinition/Main.c | 92 +- .../Lean/Elab/PreDefinition/Structural/Eqns.c | 22 +- .../stdlib/Lean/Elab/PreDefinition/WF/Eqns.c | 22 +- stage0/stdlib/Lean/Elab/Print.c | 371 +- stage0/stdlib/Lean/Elab/Quotation.c | 90 +- stage0/stdlib/Lean/Elab/StructInst.c | 92 +- stage0/stdlib/Lean/Elab/SyntheticMVars.c | 406 +- .../stdlib/Lean/Elab/Tactic/BuiltinTactic.c | 16 +- stage0/stdlib/Lean/Elab/Tactic/Conv/Pattern.c | 1658 +- stage0/stdlib/Lean/Elab/Tactic/Induction.c | 30 +- stage0/stdlib/Lean/Elab/Tactic/NormCast.c | 1784 +- stage0/stdlib/Lean/Elab/Tactic/Omega/Core.c | 188 +- .../stdlib/Lean/Elab/Tactic/Omega/Frontend.c | 92 +- stage0/stdlib/Lean/Elab/Tactic/Omega/OmegaM.c | 92 +- stage0/stdlib/Lean/Elab/Tactic/Simp.c | 3543 +- stage0/stdlib/Lean/Elab/Tactic/Simpa.c | 1176 +- stage0/stdlib/Lean/Elab/Tactic/SolveByElim.c | 2 +- stage0/stdlib/Lean/Elab/Tactic/Split.c | 432 +- stage0/stdlib/Lean/Elab/Term.c | 242 +- stage0/stdlib/Lean/Environment.c | 276 +- stage0/stdlib/Lean/InternalExceptionId.c | 2 +- stage0/stdlib/Lean/KeyedDeclsAttribute.c | 184 +- stage0/stdlib/Lean/LabelAttribute.c | 92 +- stage0/stdlib/Lean/Language/Basic.c | 790 +- stage0/stdlib/Lean/Linter/MissingDocs.c | 92 +- stage0/stdlib/Lean/Linter/UnusedVariables.c | 368 +- stage0/stdlib/Lean/Message.c | 1157 +- stage0/stdlib/Lean/Meta/AbstractMVars.c | 184 +- stage0/stdlib/Lean/Meta/AppBuilder.c | 2 +- stage0/stdlib/Lean/Meta/Basic.c | 88 +- stage0/stdlib/Lean/Meta/Canonicalizer.c | 574 +- stage0/stdlib/Lean/Meta/Check.c | 92 +- stage0/stdlib/Lean/Meta/Closure.c | 92 +- stage0/stdlib/Lean/Meta/CollectMVars.c | 92 +- stage0/stdlib/Lean/Meta/ExprDefEq.c | 3595 +- stage0/stdlib/Lean/Meta/ForEachExpr.c | 94 +- stage0/stdlib/Lean/Meta/FunInfo.c | 2 +- stage0/stdlib/Lean/Meta/InferType.c | 106 +- stage0/stdlib/Lean/Meta/LazyDiscrTree.c | 390 +- stage0/stdlib/Lean/Meta/LevelDefEq.c | 2 +- stage0/stdlib/Lean/Meta/LitValues.c | 569 +- stage0/stdlib/Lean/Meta/Match/Match.c | 90 +- stage0/stdlib/Lean/Meta/Match/MatchEqs.c | 92 +- stage0/stdlib/Lean/Meta/Match/MatcherInfo.c | 92 +- stage0/stdlib/Lean/Meta/RecursorInfo.c | 2 +- stage0/stdlib/Lean/Meta/Reduce.c | 92 +- stage0/stdlib/Lean/Meta/SizeOf.c | 2 +- stage0/stdlib/Lean/Meta/SynthInstance.c | 92 +- stage0/stdlib/Lean/Meta/Tactic/AC/Main.c | 288 +- stage0/stdlib/Lean/Meta/Tactic/Acyclic.c | 736 +- stage0/stdlib/Lean/Meta/Tactic/ElimInfo.c | 138 +- .../Lean/Meta/Tactic/Grind/Preprocessor.c | 276 +- stage0/stdlib/Lean/Meta/Tactic/Rewrite.c | 8278 +-- stage0/stdlib/Lean/Meta/Tactic/Rewrites.c | 92 +- stage0/stdlib/Lean/Meta/Tactic/Simp/Attr.c | 162 +- .../Meta/Tactic/Simp/BuiltinSimprocs/BitVec.c | 3430 +- .../Meta/Tactic/Simp/BuiltinSimprocs/Core.c | 1530 +- stage0/stdlib/Lean/Meta/Tactic/Simp/Main.c | 6464 +- stage0/stdlib/Lean/Meta/Tactic/Simp/Rewrite.c | 788 +- stage0/stdlib/Lean/Meta/Tactic/Simp/SimpAll.c | 2304 +- .../Lean/Meta/Tactic/Simp/SimpCongrTheorems.c | 92 +- stage0/stdlib/Lean/Meta/Tactic/Simp/Simproc.c | 276 +- stage0/stdlib/Lean/Meta/Tactic/Simp/Types.c | 205 +- stage0/stdlib/Lean/Meta/Tactic/Split.c | 8773 +-- stage0/stdlib/Lean/Meta/Tactic/SplitIf.c | 6 +- stage0/stdlib/Lean/Meta/Tactic/Unfold.c | 68 +- stage0/stdlib/Lean/Meta/Tactic/Util.c | 164 +- stage0/stdlib/Lean/MetavarContext.c | 3793 +- stage0/stdlib/Lean/Parser/Module.c | 4 +- stage0/stdlib/Lean/Parser/Types.c | 110 +- .../Delaborator/TopDownAnalyze.c | 94 +- stage0/stdlib/Lean/ReducibilityAttrs.c | 94 +- stage0/stdlib/Lean/Replay.c | 2 +- stage0/stdlib/Lean/ResolveName.c | 92 +- stage0/stdlib/Lean/ScopedEnvExtension.c | 184 +- stage0/stdlib/Lean/Server/Completion.c | 4 +- stage0/stdlib/Lean/Server/FileWorker.c | 4 +- .../Lean/Server/FileWorker/RequestHandling.c | 170 +- stage0/stdlib/Lean/Server/ImportCompletion.c | 1227 +- stage0/stdlib/Lean/Server/References.c | 1056 +- stage0/stdlib/Lean/Server/Watchdog.c | 8430 ++- stage0/stdlib/Lean/Structure.c | 2 +- stage0/stdlib/Lean/Syntax.c | 580 +- stage0/stdlib/Lean/Util/CollectFVars.c | 92 +- stage0/stdlib/Lean/Util/CollectLevelParams.c | 184 +- stage0/stdlib/Lean/Util/CollectMVars.c | 92 +- stage0/stdlib/Lean/Util/FindExpr.c | 100 +- stage0/stdlib/Lean/Util/ForEachExpr.c | 92 +- stage0/stdlib/Lean/Util/ForEachExprWhere.c | 92 +- stage0/stdlib/Lean/Util/HasConstCache.c | 126 +- stage0/stdlib/Lean/Util/Path.c | 922 +- stage0/stdlib/Lean/Util/Profiler.c | 511 +- stage0/stdlib/Lean/Util/PtrSet.c | 104 +- 273 files changed, 586047 insertions(+), 39379 deletions(-) create mode 100644 stage0/src/lake/README.md create mode 100644 stage0/src/lakefile.toml.in create mode 100644 stage0/stdlib/Lake.c create mode 100644 stage0/stdlib/Lake/Build.c create mode 100644 stage0/stdlib/Lake/Build/Actions.c create mode 100644 stage0/stdlib/Lake/Build/Basic.c create mode 100644 stage0/stdlib/Lake/Build/Common.c create mode 100644 stage0/stdlib/Lake/Build/Data.c create mode 100644 stage0/stdlib/Lake/Build/Executable.c create mode 100644 stage0/stdlib/Lake/Build/Facets.c create mode 100644 stage0/stdlib/Lake/Build/Fetch.c create mode 100644 stage0/stdlib/Lake/Build/Imports.c create mode 100644 stage0/stdlib/Lake/Build/Index.c create mode 100644 stage0/stdlib/Lake/Build/Info.c create mode 100644 stage0/stdlib/Lake/Build/Job.c create mode 100644 stage0/stdlib/Lake/Build/Key.c create mode 100644 stage0/stdlib/Lake/Build/Library.c create mode 100644 stage0/stdlib/Lake/Build/Module.c create mode 100644 stage0/stdlib/Lake/Build/Package.c create mode 100644 stage0/stdlib/Lake/Build/Run.c create mode 100644 stage0/stdlib/Lake/Build/Store.c create mode 100644 stage0/stdlib/Lake/Build/Targets.c create mode 100644 stage0/stdlib/Lake/Build/Topological.c create mode 100644 stage0/stdlib/Lake/Build/Trace.c create mode 100644 stage0/stdlib/Lake/CLI.c create mode 100644 stage0/stdlib/Lake/CLI/Actions.c create mode 100644 stage0/stdlib/Lake/CLI/Build.c create mode 100644 stage0/stdlib/Lake/CLI/Error.c create mode 100644 stage0/stdlib/Lake/CLI/Help.c create mode 100644 stage0/stdlib/Lake/CLI/Init.c create mode 100644 stage0/stdlib/Lake/CLI/Main.c create mode 100644 stage0/stdlib/Lake/CLI/Serve.c create mode 100644 stage0/stdlib/Lake/CLI/Translate.c create mode 100644 stage0/stdlib/Lake/CLI/Translate/Lean.c create mode 100644 stage0/stdlib/Lake/CLI/Translate/Toml.c create mode 100644 stage0/stdlib/Lake/Config.c create mode 100644 stage0/stdlib/Lake/Config/Context.c create mode 100644 stage0/stdlib/Lake/Config/Defaults.c create mode 100644 stage0/stdlib/Lake/Config/Dependency.c create mode 100644 stage0/stdlib/Lake/Config/Env.c create mode 100644 stage0/stdlib/Lake/Config/ExternLib.c create mode 100644 stage0/stdlib/Lake/Config/ExternLibConfig.c create mode 100644 stage0/stdlib/Lake/Config/FacetConfig.c create mode 100644 stage0/stdlib/Lake/Config/Glob.c create mode 100644 stage0/stdlib/Lake/Config/InstallPath.c create mode 100644 stage0/stdlib/Lake/Config/Lang.c create mode 100644 stage0/stdlib/Lake/Config/LeanConfig.c create mode 100644 stage0/stdlib/Lake/Config/LeanExe.c create mode 100644 stage0/stdlib/Lake/Config/LeanExeConfig.c create mode 100644 stage0/stdlib/Lake/Config/LeanLib.c create mode 100644 stage0/stdlib/Lake/Config/LeanLibConfig.c create mode 100644 stage0/stdlib/Lake/Config/Module.c create mode 100644 stage0/stdlib/Lake/Config/Monad.c create mode 100644 stage0/stdlib/Lake/Config/Opaque.c create mode 100644 stage0/stdlib/Lake/Config/Package.c create mode 100644 stage0/stdlib/Lake/Config/Script.c create mode 100644 stage0/stdlib/Lake/Config/TargetConfig.c create mode 100644 stage0/stdlib/Lake/Config/Workspace.c create mode 100644 stage0/stdlib/Lake/Config/WorkspaceConfig.c create mode 100644 stage0/stdlib/Lake/DSL.c create mode 100644 stage0/stdlib/Lake/DSL/Attributes.c create mode 100644 stage0/stdlib/Lake/DSL/AttributesCore.c create mode 100644 stage0/stdlib/Lake/DSL/Config.c create mode 100644 stage0/stdlib/Lake/DSL/DeclUtil.c create mode 100644 stage0/stdlib/Lake/DSL/Extensions.c create mode 100644 stage0/stdlib/Lake/DSL/Meta.c create mode 100644 stage0/stdlib/Lake/DSL/Package.c create mode 100644 stage0/stdlib/Lake/DSL/Require.c create mode 100644 stage0/stdlib/Lake/DSL/Script.c create mode 100644 stage0/stdlib/Lake/DSL/Targets.c create mode 100644 stage0/stdlib/Lake/Load.c create mode 100644 stage0/stdlib/Lake/Load/Config.c create mode 100644 stage0/stdlib/Lake/Load/Lean.c create mode 100644 stage0/stdlib/Lake/Load/Lean/Elab.c create mode 100644 stage0/stdlib/Lake/Load/Lean/Eval.c create mode 100644 stage0/stdlib/Lake/Load/Manifest.c create mode 100644 stage0/stdlib/Lake/Load/Materialize.c create mode 100644 stage0/stdlib/Lake/Load/Package.c create mode 100644 stage0/stdlib/Lake/Load/Resolve.c create mode 100644 stage0/stdlib/Lake/Load/Toml.c create mode 100644 stage0/stdlib/Lake/Load/Workspace.c create mode 100644 stage0/stdlib/Lake/Main.c create mode 100644 stage0/stdlib/Lake/Toml.c create mode 100644 stage0/stdlib/Lake/Toml/Data.c create mode 100644 stage0/stdlib/Lake/Toml/Data/DateTime.c create mode 100644 stage0/stdlib/Lake/Toml/Data/Dict.c create mode 100644 stage0/stdlib/Lake/Toml/Data/Value.c create mode 100644 stage0/stdlib/Lake/Toml/Decode.c create mode 100644 stage0/stdlib/Lake/Toml/Elab.c create mode 100644 stage0/stdlib/Lake/Toml/Elab/Expression.c create mode 100644 stage0/stdlib/Lake/Toml/Elab/Value.c create mode 100644 stage0/stdlib/Lake/Toml/Encode.c create mode 100644 stage0/stdlib/Lake/Toml/Grammar.c create mode 100644 stage0/stdlib/Lake/Toml/Load.c create mode 100644 stage0/stdlib/Lake/Toml/ParserUtil.c create mode 100644 stage0/stdlib/Lake/Util/Binder.c create mode 100644 stage0/stdlib/Lake/Util/Casing.c create mode 100644 stage0/stdlib/Lake/Util/Cli.c create mode 100644 stage0/stdlib/Lake/Util/Compare.c create mode 100644 stage0/stdlib/Lake/Util/Cycle.c create mode 100644 stage0/stdlib/Lake/Util/DRBMap.c create mode 100644 stage0/stdlib/Lake/Util/EStateT.c create mode 100644 stage0/stdlib/Lake/Util/EquipT.c create mode 100644 stage0/stdlib/Lake/Util/Error.c create mode 100644 stage0/stdlib/Lake/Util/Exit.c create mode 100644 stage0/stdlib/Lake/Util/Family.c create mode 100644 stage0/stdlib/Lake/Util/FilePath.c create mode 100644 stage0/stdlib/Lake/Util/Git.c create mode 100644 stage0/stdlib/Lake/Util/IO.c create mode 100644 stage0/stdlib/Lake/Util/JsonObject.c create mode 100644 stage0/stdlib/Lake/Util/Lift.c create mode 100644 stage0/stdlib/Lake/Util/List.c create mode 100644 stage0/stdlib/Lake/Util/Lock.c create mode 100644 stage0/stdlib/Lake/Util/Log.c create mode 100644 stage0/stdlib/Lake/Util/MainM.c create mode 100644 stage0/stdlib/Lake/Util/Message.c create mode 100644 stage0/stdlib/Lake/Util/Name.c create mode 100644 stage0/stdlib/Lake/Util/NativeLib.c create mode 100644 stage0/stdlib/Lake/Util/Opaque.c create mode 100644 stage0/stdlib/Lake/Util/OrdHashSet.c create mode 100644 stage0/stdlib/Lake/Util/OrderedTagAttribute.c create mode 100644 stage0/stdlib/Lake/Util/Proc.c create mode 100644 stage0/stdlib/Lake/Util/RBArray.c create mode 100644 stage0/stdlib/Lake/Util/Store.c create mode 100644 stage0/stdlib/Lake/Util/StoreInsts.c create mode 100644 stage0/stdlib/Lake/Util/Sugar.c create mode 100644 stage0/stdlib/Lake/Util/Task.c create mode 100644 stage0/stdlib/Lake/Util/Version.c create mode 100644 stage0/stdlib/Lake/Version.c diff --git a/stage0/src/CMakeLists.txt b/stage0/src/CMakeLists.txt index 811d404f1e..f2cc9beae6 100644 --- a/stage0/src/CMakeLists.txt +++ b/stage0/src/CMakeLists.txt @@ -73,6 +73,7 @@ option(USE_GMP "USE_GMP" ON) # development-specific options option(CHECK_OLEAN_VERSION "Only load .olean files compiled with the current version of Lean" OFF) +option(USE_LAKE "Use Lake instead of lean.mk for building core libs from language server" OFF) set(LEAN_EXTRA_MAKE_OPTS "" CACHE STRING "extra options to lean --make") set(LEANC_CC ${CMAKE_C_COMPILER} CACHE STRING "C compiler to use in `leanc`") @@ -577,16 +578,12 @@ else() string(APPEND CMAKE_EXE_LINKER_FLAGS " -lInit_shared -lleanshared") endif() -if(${STAGE} GREATER 0 AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten") - if(NOT EXISTS ${LEAN_SOURCE_DIR}/lake/Lake.lean) - message(FATAL_ERROR "src/lake does not exist. Please check out the Lake submodule using `git submodule update --init src/lake`.") - endif() - - #add_custom_target(lake ALL - # WORKING_DIRECTORY ${LEAN_SOURCE_DIR} - # DEPENDS leanshared - # COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Lake - # VERBATIM) +if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten") + add_custom_target(lake ALL + WORKING_DIRECTORY ${LEAN_SOURCE_DIR} + DEPENDS leanshared + COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Lake + VERBATIM) endif() if(PREV_STAGE) @@ -658,3 +655,9 @@ endif() string(REPLACE "$" "$$" CMAKE_EXE_LINKER_FLAGS_MAKE "${CMAKE_EXE_LINKER_FLAGS}") string(REPLACE "$" "$$" CMAKE_EXE_LINKER_FLAGS_MAKE_MAKE "${CMAKE_EXE_LINKER_FLAGS_MAKE}") configure_file(${LEAN_SOURCE_DIR}/stdlib.make.in ${CMAKE_BINARY_DIR}/stdlib.make) + +if(USE_LAKE AND STAGE EQUAL 1) + configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/lakefile.toml) + configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/../tests/lakefile.toml) + configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/../lakefile.toml) +endif() diff --git a/stage0/src/lake/README.md b/stage0/src/lake/README.md new file mode 100644 index 0000000000..e08bf9e64e --- /dev/null +++ b/stage0/src/lake/README.md @@ -0,0 +1,450 @@ +# Lake + +Lake (Lean Make) is the new build system and package manager for Lean 4. +With Lake, the package's configuration is written in Lean inside a dedicated `lakefile.lean` stored in the root of the package's directory. + +Each `lakefile.lean` includes a `package` declaration (akin to `main`) which defines the package's basic configuration. It also typically includes build configurations for different targets (e.g., Lean libraries and binary executables) and Lean scripts to run on the command line (via `lake script run`). + +***This README provides information about Lake relative to the current commit. If you are looking for documentation for the Lake version shipped with a given Lean release, you should look at the README of that version.*** + +## Table of Contents + +* [Getting Lake](#getting-lake) +* [Creating and Building a Package](#creating-and-building-a-package) +* [Glossary of Terms](#glossary-of-terms) +* [Package Configuration Options](#package-configuration-options) + + [Layout](#layout) + + [Build & Run](#build--run) + + [Test & Lint](#test--lint) + + [Cloud Releases](#cloud-releases) +* [Defining Build Targets](#defining-build-targets) + + [Lean Libraries](#lean-libraries) + + [Binary Executables](#binary-executables) + + [External Libraries](#external-libraries) + + [Custom Targets](#custom-targets) +* [Defining New Facets](#defining-new-facets) +* [Adding Dependencies](#adding-dependencies) + + [Syntax of `require`](#syntax-of-require) +* [GitHub Release Builds](#github-release-builds) +* [Writing and Running Scripts](#writing-and-running-scripts) +* [Building and Running Lake from the Source](#building-and-running-lake-from-the-source) + + [Building with Nix Flakes](#building-with-nix-flakes) + + [Augmenting Lake's Search Path](#augmenting-lakes-search-path) + +## Getting Lake + +Lake is part of the [lean4](https://github.com/leanprover/lean4) repository and is distributed along with its official releases (e.g., as part of the [elan](https://github.com/leanprover/elan) toolchain). So if you have installed a semi-recent Lean 4 nightly, you should already have it! If you want to build the latest version from the source yourself, check out the [build instructions](#building-and-running-lake-from-the-source) at the bottom of this README. + +## Creating and Building a Package + +To create a new package, either run `lake init` to setup the package in the current directory or `lake new` to create it in a new directory. For example, we could create the package `hello` like so: + +``` +$ mkdir hello +$ cd hello +$ lake init hello +``` + +or like so: + +``` +$ lake new hello +$ cd hello +``` + +Either way, Lake will create the following template directory structure and initialize a Git repository for the package. + +``` +.lake/ # Lake output directory +Hello/ # library source files; accessible via `import Hello.*` + Basic.lean # an example library module file + ... # additional files should be added here +Hello.lean # library root; imports standard modules from Hello +Main.lean # main file of the executable (contains `def main`) +lakefile.lean # Lake package configuration +lean-toolchain # the Lean version used by the package +.gitignore # excludes system-specific files (e.g. `build`) from Git +``` + +The example modules files contain the following dummy "Hello World" program. + +**Hello/Basic.lean** +```lean +def hello := "world" +``` + +**Hello.lean** +```lean +-- This module serves as the root of the `Hello` library. +-- Import modules here that should be built as part of the library. +import «Hello».Basic +``` + +**Main.lean** +```lean +import «Hello» + +def main : IO Unit := + IO.println s!"Hello, {hello}!" +``` + +Lake also creates a basic `lakefile.lean` for the package along with a `lean-toolchain` file that contains the name of the Lean toolchain Lake belongs to, which tells [`elan`](https://github.com/leanprover/elan) to use that Lean toolchain for the package. + + +**lakefile.lean** +```lean +import Lake +open Lake DSL + +package «hello» where + -- add package configuration options here + +lean_lib «Hello» where + -- add library configuration options here + +@[default_target] +lean_exe «hello» where + root := `Main +``` + +The command `lake build` is used to build the package (and its [dependencies](#adding-dependencies), if it has them) into a native executable. The result will be placed in `.lake/build/bin`. The command `lake clean` deletes `build`. + +``` +$ lake build +... +$ ./.lake/build/bin/hello +Hello, world! +``` + +Examples of different package configurations can be found in the [`examples`](examples) folder of this repository. You can also pass a package template tp `lake init` or `lake new` to control what files Lake creates. For example, instead of using a Lean configuration file for this package, one could produce a TOML version via `lake new hello .toml`. + +**lakefile.toml** +```toml +name = "hello" +defaultTargets = ["hello"] + +[[lean_lib]] +name = "Hello" + +[[lean_exe]] +name = "hello" +root = "Main" +``` + +See `lake help init` or `lake help new` for more details on other template options. + +## Glossary of Terms + +Lake uses a lot of terms common in software development -- like workspace, package, library, executable, target, etc. -- and some more esoteric ones -- like facet. However, whether common or not, these terms mean different things to different people, so it is important to elucidate how Lake defines these terms: + +* A **package** is the **fundamental unit of code distribution in Lake**. Packages can be sourced from the local file system or downloaded from the web (e.g., via Git). The `package` declaration in package's lakefile names it and [defines its basic properties](#package-configuration-options). + +* A **lakefile** is the Lean file that configures a package. It defines how to view, edit, build, and run the code within it, and it specifies what other packages it may require in order to do so. + +* If package `B` requires package `A`, then package `A` is a **dependency** of package B and package `B` is its **dependent**. Package `A` is **upstream** of package `B` and package `B` is reversely **downstream** of package `A`. See the [Adding Dependencies section](#adding-dependencies) for details on how to specify dependencies. + +* A **workspace** is the **broadest organizational unit in Lake**. It bundles together a package (termed the **root**), its transitive dependencies, and Lake's environment. Every package can operate as the root of a workspace and the workspace will derive its configuration from this root. + +* A **module** is the **smallest unit of code visible to Lake's build system**. It is generally represented by a Lean source file and a set of binary libraries (i.e., a Lean `olean` and `ilean` plus a system shared library if `precompileModules` is turned on). Modules can import one another in order to use each other's code and Lake exists primarily to facilitate this process. + +* A **Lean library** is a collection of modules that share a single configuration. Its configuration defines a set of **module roots** that determines which modules are part of the library, and a set of **module globs** that selects which modules to build on a `lake build` of the library. See the [Lean Libraries section](#lean-libraries) for more details. + +* A **Lean binary executable** is a binary executable (i.e., a program a user can run on their computer without Lean installed) built from a Lean module termed its **root** (which should have a `main` definition). See the [Binary Executables section](#binary-executables) for more details. + +* An **external library** is a native (static) library built from foreign code (e.g., C) that is required by a package's Lean code in order to function (e.g., because it uses `@[extern]` to invoke code written in a foreign language). An `extern_lib` target is used to inform Lake of such a requirement and instruct Lake on how to build requisite library. Lake then automatically links the external library when appropriate to give the Lean code access to the foreign functions (or, more technically, the foreign symbols) it needs. See the [External Libraries section](#external-libraries) for more details. + +* A **target** is the **fundamental build unit of Lake**. A package can defining any number of targets. Each target has a name, which is used to instruct Lake to build the target (e.g., through `lake build `) and to keep track internally of a target's build status. Lake defines a set of builtin target types -- [Lean libraries](#lean-libraries), [binary executables](#binary-executables), and [external libraries](#external-libraries) -- but a user can [define their own custom targets as well](#custom-targets). Complex types (e.g., packages, libraries, modules) have multiple facets, each of which count as separate buildable targets. See the [Defining Build Targets section](#defining-build-targets) for more details. + +* A **facet** is an element built from another organizational unit (e.g., a package, module, library, etc.). For instance, Lake produces `olean`, `ilean`, `c`, and `o` files all from a single module. Each of these components are thus termed a *facet* of the module. Similarly, Lake can build both static and shared binaries from a library. Thus, libraries have both `static` and `shared` facets. Lake also allows users to define their own custom facets to build from modules and packages, but this feature is currently experimental and not yet documented. + +* A **trace** is a piece of data (generally a hash) which is used to verify whether a given target is up-to-date (i.e., does not need to be rebuilt). If the trace stored with a built target matches the trace computed during build, then a target is considered up-to-date. A target's trace is derived from its various **inputs** (e.g., source file, Lean toolchain, imports, etc.). + +## Package Configuration Options + +Lake provides a large assortment of configuration options for packages. + +### Layout + +These options control the top-level directory layout of the package and its build directory. Further paths specified by libraries, executables, and targets within the package are relative to these directories. + +* `packagesDir`: The directory to which Lake should download remote dependencies. Defaults to `.lake/packages`. +* `srcDir`: The directory containing the package's Lean source files. Defaults to the package's directory. +* `buildDir`: The directory to which Lake should output the package's build results. Defaults to `build`. +* `leanLibDir`: The build subdirectory to which Lake should output the package's binary Lean libraries (e.g., `.olean`, `.ilean` files). Defaults to `lib`. +* `nativeLibDir`: The build subdirectory to which Lake should output the package's native libraries (e.g., `.a`, `.so`, `.dll` files). Defaults to `lib`. +* `binDir`: The build subdirectory to which Lake should output the package's binary executables. Defaults to `bin`. +* `irDir`: The build subdirectory to which Lake should output the package's intermediary results (e.g., `.c`, `.o` files). Defaults to `ir`. + +### Build & Run + +These options configure how code is built and run in the package. Libraries, executables, and other targets within a package can further add to parts of this configuration. + +* `platformIndependent`: Asserts whether Lake should assume Lean modules are platform-independent. That is, whether lake should include the platform and platform-dependent elements in a module's trace. See the docstring of `Lake.LeanConfig.platformIndependent` for more details. Defaults to `none`. +* `precompileModules`: Whether to compile each module into a native shared library that is loaded whenever the module is imported. This speeds up the evaluation of metaprograms and enables the interpreter to run functions marked `@[extern]`. Defaults to `false`. +* `moreServerOptions`: An `Array` of additional options to pass to the Lean language server (i.e., `lean --server`) launched by `lake serve`. +* `moreGlobalServerArgs`: An `Array` of additional arguments to pass to `lean --server` which apply both to this package and anything else in the same server session (e.g. when browsing other packages from the same session via go-to-definition) +* `buildType`: The `BuildType` of targets in the package (see [`CMAKE_BUILD_TYPE`](https://stackoverflow.com/a/59314670)). One of `debug`, `relWithDebInfo`, `minSizeRel`, or `release`. Defaults to `release`. +* `leanOptions`: Additional options to pass to both the Lean language server (i.e., `lean --server`) launched by `lake serve` and to `lean` while compiling Lean source files. +* `moreLeanArgs`: An `Array` of additional arguments to pass to `lean` while compiling Lean source files. +* `weakLeanArgs`: An `Array` of additional arguments to pass to `lean` while compiling Lean source files. Unlike `moreLeanArgs`, these arguments do not affect the trace of the build result, so they can be changed without triggering a rebuild. They come *before* `moreLeanArgs`. +* `moreLeancArgs`: An `Array` of additional arguments to pass to `leanc` while compiling the C source files generated by `lean`. Lake already passes some flags based on the `buildType`, but you can change this by, for example, adding `-O0` and `-UNDEBUG`. +* `weakLeancArgs`: An `Array` of additional arguments to pass to `leanc` while compiling the C source files generated by `lean`. Unlike `moreLeancArgs`, these arguments do not affect the trace of the build result, so they can be changed without triggering a rebuild. They come *before* `moreLeancArgs`. +* `moreLinkArgs`: An `Array` of additional arguments to pass to `leanc` when linking (e.g., binary executables or shared libraries). These will come *after* the paths of `extern_lib` targets. +* `weakLinkArgs`: An `Array` of additional arguments to pass to `leanc` when linking (e.g., binary executables or shared libraries) Unlike `moreLinkArgs`, these arguments do not affect the trace of the build result, so they can be changed without triggering a rebuild. They come *before* `moreLinkArgs`. +* `extraDepTargets`: An `Array` of [target](#custom-targets) names that the package should always build before anything else. + +### Test & Lint + +The CLI commands `lake test` and `lake lint` use definitions configured by the workspace's root package to perform testing and linting (this referred to as the test or lint *driver*). In Lean configuration files, these can be specified by applying the `@[test_driver]` or `@[lint_driver]` to a `script`, `lean_exe`, or `lean_lb`. They can also be configured (in Lean or TOML format) via the following options on the package. + +* `testDriver`: The name of the script, executable, or library to drive `lake test`. +* `testDriverArgs`: An `Array` of arguments to pass to the package's test driver. +* `lintDriver`: The name of the script or executable used by `lake lint`. Libraries cannot be lint drivers. +* `lintDriverArgs`: An `Array` of arguments to pass to the package's lint driver. + +You can specify definition from a dependency as a package's test or lint driver by using the syntax `/`. An executable driver will be built and then run, a script driver will just be run, and a library driver will just be built. A script or executable driver is run with any arguments configured by package (e.g., via `testDriverArgs`) followed by any specified on the CLI (e.g., via `lake lint -- ...`). + +### Cloud Releases + +These options define a cloud release for the package. See the section on [GitHub Release Builds](#github-release-builds) for more information. + +* `releaseRepo`: The URL of the GitHub repository to upload and download releases of this package. If `none` (the default), for downloads, Lake uses the URL the package was download from (if it is a dependency) and for uploads, uses `gh`'s default. +* `buildArchive`: The name of the build archive for the GitHub cloud release. +Defaults to `{(pkg-)name}-{System.Platform.target}.tar.gz`. +* `preferReleaseBuild`: Whether to prefer downloading a prebuilt release (from GitHub) rather than building this package from the source when this package is used as a dependency. + +## Defining Build Targets + +A Lake package can have many build targets, such as different Lean libraries and multiple binary executables. Any number of these declarations can be marked with the `@[default_target]` attribute to tell Lake to build them on a bare `lake build` of the package. + +### Lean Libraries + +A Lean library target defines a set of Lean modules available to `import` and how to build them. + +**Syntax** + +```lean +lean_lib «target-name» where + -- configuration options go here +``` + +```toml +[[lean_lib]] +name = "«target-name»" +# more configuration options go here +``` + +**Configuration Options** + +* `srcDir`: The subdirectory of the package's source directory containing the library's source files. Defaults to the package's `srcDir`. (This will be passed to `lean` as the `-R` option.) +* `roots`: An `Array` of root module `Name`(s) of the library. Submodules of these roots (e.g., `Lib.Foo` of `Lib`) are considered part of the library. Defaults to a single root of the target's name. +* `globs`: An `Array` of module `Glob`(s) to build for the library. The term `glob` comes from [file globs](https://en.wikipedia.org/wiki/Glob_(programming)) (e.g., `foo/*`) on Unix. A submodule glob builds every Lean source file within the module's directory (i.e., ``Glob.submodules `Foo`` is essentially equivalent to a theoretical `import Foo.*`). Local imports of glob'ed files (i.e., fellow modules of the workspace) are also recursively built. Defaults to a `Glob.one` of each of the library's `roots`. +* `libName`: The `String` name of the library. Used as a base for the file names of its static and dynamic binaries. Defaults to the name of the target. +* `extraDepTargets`: An `Array` of [target](#custom-targets) names to build before the library's modules. +* `defaultFacets`: An `Array` of library facets to build on a bare `lake build` of the library. For example, setting this to `#[LeanLib.sharedLib]` will build the shared library facet. +* `nativeFacets`: A function `(shouldExport : Bool) → Array` determining the [module facets](#defining-new-facets) to build and combine into the library's static and shared libraries. If `shouldExport` is true, the module facets should export any symbols a user may expect to lookup in the library. For example, the Lean interpreter will use exported symbols in linked libraries. Defaults to a singleton of `Module.oExportFacet` (if `shouldExport`) or `Module.oFacet`. That is, the object files compiled from the Lean sources, potentially with exported Lean symbols. +* `platformIndependent`, `precompileModules`, `buildType`, `leanOptions`, `Args`, `moreServerOptions`: Augments the package's corresponding configuration option. The library's arguments come after, modules are precompiled if either the library or package are, `platformIndependent` falls back to the package on `none`, and the build type is the minimum of the two (`debug` is the lowest, and `release` is the highest). + +### Binary Executables + +A Lean executable target builds a binary executable from a Lean module with a `main` function. + +**Syntax** + +```lean +lean_exe «target-name» where + -- configuration options go here +``` + +```toml +[[lean_exe]] +name = "«target-name»" +# more configuration options go here +``` + +**Configuration Options** + +* `srcDir`: The subdirectory of the package's source directory containing the executable's source file. Defaults to the package's `srcDir`. (This will be passed to `lean` as the `-R` option.) +* `root`: The root module `Name` of the binary executable. Should include a `main` definition that will serve as the entry point of the program. The root is built by recursively building its local imports (i.e., fellow modules of the workspace). Defaults to the name of the target. +* `exeName`: The `String` name of the binary executable. Defaults to the target name with any `.` replaced with a `-`. +* `extraDepTargets`: An `Array` of [target](#custom-targets) names to build before the executable's modules. +* `nativeFacets`: A function `(shouldExport : Bool) → Array` determining the [module facets](#defining-new-facets) to build and link into the executable. If `shouldExport` is true, the module facets should export any symbols a user may expect to lookup in the library. For example, the Lean interpreter will use exported symbols in linked libraries. Defaults to a singleton of `Module.oExportFacet` (if `shouldExport`) or `Module.oFacet`. That is, the object file compiled from the Lean source, potentially with exported Lean symbols. +* `supportInterpreter`: Whether to expose symbols within the executable to the Lean interpreter. This allows the executable to interpret Lean files (e.g., via `Lean.Elab.runFrontend`). Implementation-wise, on Windows, the Lean shared libraries are linked to the executable and, on other systems, the executable is linked with `-rdynamic`. This increases the size of the binary on Linux and, on Windows, requires `libInit_shared.dll` and `libleanshared.dll` to be co-located with the executable or part of `PATH` (e.g., via `lake exe`). Thus, this feature should only be enabled when necessary. Defaults to `false`. +* `platformIndependent`, `precompileModules`, `buildType`, `leanOptions`, `Args`, `moreServerOptions`: Augments the package's corresponding configuration option. The library's arguments come after, modules are precompiled if either the library or package are, `platformIndependent` falls back to the package on `none`, and the build type is the minimum of the two (`debug` is the lowest, and `release` is the highest). + +### External Libraries + +A external library target is a non-Lean **static** library that will be linked to the binaries of the package and its dependents (e.g., their shared libraries and executables). + +**Important:** For the external library to link properly when `precompileModules` is on, the static library produced by an `extern_lib` target must following the platform's naming conventions for libraries (i.e., be named `foo.a` on Windows and `libfoo.a` on Unix). To make this easy, there is the `Lake.nameToStaticLib` utility function to convert a library name into its proper file name for the platform. + +**Syntax** + +```lean +extern_lib «target-name» (pkg : NPackage _package.name) := + -- a build function that produces its static library +``` + +The declaration is essentially a wrapper around a `System.FilePath` [target](#custom-targets). Like such a target, the `pkg` parameter and its type specifier are optional and body should be a term of type `FetchM (BuildJob System.FilePath)` function that builds the static library. The `pkg` parameter is of type `NPackage _package.name` to provably demonstrate that it is the package in which the external library is defined. + +### Custom Targets + +A arbitrary target that can be built via `lake build `. + +**Syntax** + +```lean +target «target-name» (pkg : NPackage _package.name) : α := + -- a build function that produces a `BuildJob α` +``` + +The `pkg` parameter and its type specifier are optional and the body should be a term of type `FetchM (BuildJob α)`. The `pkg` parameter is of type `NPackage _package.name` to provably demonstrate that it is the package in which the target is defined. + +## Defining New Facets + +A Lake package can also define new *facets* for packages, modules, and libraries. Once defined, the new facet (e.g., `facet`) can be built on any current or future object of its type (e.g., through `lake build pkg:facet` for a package facet). Module facets can also be provided to [`LeanLib.nativeFacets`](#lean-libraries) to have Lake build and use them automatically when producing shared libraries. + +**Syntax** + +```lean +package_facet «facet-name» (pkg : Package) : α := + -- a build function that produces a `BuildJob α` + +module_facet «facet-name» (mod : Module) : α := + -- a build function that produces a `BuildJob α` + +library_facet «facet-name» (lib : LeanLib) : α := + -- a build function that produces a `BuildJob α` +``` + +In all of these, the object parameter and its type specifier are optional and the body should be a term of type `FetchM (BuildJob α)`. + +## Adding Dependencies + +Lake packages can have dependencies. Dependencies are other Lake packages the current package needs in order to function. They can be sourced directly from a local folder (e.g., a subdirectory of the package) or come from remote Git repositories. For example, one can depend on [mathlib](https://github.com/leanprover-community/mathlib4) like so: + +```lean +package hello + +require mathlib from git + "https://github.com/leanprover-community/mathlib4.git" +``` + +The next run of `lake build` (or refreshing dependencies in an editor like VSCode) will clone the mathlib repository and build it. Information on the specific revision cloned will then be saved to `lake-manifest.json` to enable reproducibility (i.e., ensure the same version of mathlib is used by future builds). To update `mathlib` after this, you will need to run `lake update` -- other commands do not update resolved dependencies. + +For theorem proving packages which depend on `mathlib`, you can also run `lake new math` to generate a package configuration file that already has the `mathlib` dependency (and no binary executable target). + +**NOTE:** For mathlib in particular, you should run `lake exe cache get` prior to a `lake build` after adding or updating a mathlib dependency. Otherwise, it will be rebuilt from scratch (which can take hours). For more information, see mathlib's [wiki page](https://github.com/leanprover-community/mathlib4/wiki/Using-mathlib4-as-a-dependency) on using it as a dependency. + +### Syntax of `require` + +The `require` command has two forms: + +```lean +require foo from "path"/"to"/"local"/"package" with NameMap.empty +require bar from git "url.git"@"rev"/"optional"/"path-to"/"dir-with-pkg" +``` + +The first form adds a local dependency and the second form adds a Git dependency. For a Git dependency, the revision can be a commit hash, branch, or tag. Also, the `@"rev"` and `/"path-to"/"term"` parts of the `require` are optional. + +Both forms also support an optional `with` clause to specify arguments to pass to the dependency's package configuration (i.e., same as `args` in a `lake build -- ` invocation). The elements of both the `from` and `with` clauses are proper terms so normal computation is supported within them (though parentheses made be required to disambiguate the syntax). + +To `require` a package in a TOML configuration, the equivalent syntax is: + +```toml +[[require]] +path = "path/to/local/package" +options = {} + +[[require]] +git = "url.git" +rev = "rev" +subDir = "optional/path-to/dir-with-pkg" +``` + +## GitHub Release Builds + +Lake supports uploading and downloading build artifacts (i.e., the archived build directory) to/from the GitHub releases of packages. This enables end users to fetch pre-built artifacts from the cloud without needed to rebuild the package from the source themselves. + +### Downloading + +To download artifacts, one should configure the package [options](#cloud-releases) `releaseRepo?` and `buildArchive?` as necessary to point to the GitHub repository hosting the release and the correct artifact name within it (if the defaults are not sufficient). Then, set `preferReleaseBuild := true` to tell Lake to fetch and unpack it as an extra package dependency. + +Lake will only fetch release builds as part of its standard build process if the package wanting it is a dependency (as the root package is expected to modified and thus not often compatible with this scheme). However, should one wish to fetch a release for a root package (e.g., after cloning the release's source but before editing), one can manually do so via `lake build :release`. + +Lake internally uses `curl` to download the release and `tar` to unpack it, so the end user must have both tools installed to use this feature. If Lake fails to fetch a release for any reason, it will move on to building from the source. Also note that this mechanism is not technically limited to GitHub, any Git host that uses the same URL scheme works as well. + +### Uploading + +To upload a built package as an artifact to a GitHub release, Lake provides the `lake upload ` command as a convenient shorthand. This command uses `tar` to pack the package's build directory into an archive and uses `gh release upload` to attach it to a pre-existing GitHub release for `tag`. Thus, in order to use it, the package uploader (but not the downloader) needs to have `gh`, the [GitHub CLI](https://cli.github.com/), installed and in `PATH`. + +## Writing and Running Scripts + +A configuration file can also contain a number of `scripts` declaration. A script is an arbitrary `(args : List String) → ScriptM UInt32` definition that can be run by `lake script run`. For example, given the following `lakefile.lean`: + +```lean +import Lake +open Lake DSL + +package scripts + +/-- +Display a greeting + +USAGE: + lake run greet [name] + +Greet the entity with the given name. Otherwise, greet the whole world. +-/ +script greet (args) do + if h : 0 < args.length then + IO.println s!"Hello, {args[0]'h}!" + else + IO.println "Hello, world!" + return 0 +``` + +The script `greet` can be run like so: + +``` +$ lake script run greet +Hello, world! +$ lake script run greet me +Hello, me! +``` + +You can print the docstring of a script with `lake script doc`: + +``` +$ lake script doc greet +Display a greeting + +USAGE: + lake run greet [name] + +Greet the entity with the given name. Otherwise, greet the whole world. +``` + +## Building and Running Lake from the Source + +If you already have a Lean installation with `lake` packaged with it, you can build a new `lake` by just running `lake build`. + +Otherwise, there is a pre-packaged `build.sh` shell script that can be used to build Lake. It passes it arguments down to a `make` command. So, if you have more than one core, you will probably want to use a `-jX` option to specify how many build tasks you want it to run in parallel. For example: + +```shell +$ ./build.sh -j4 +``` + +After building, the `lake` binary will be located at `.lake/build/bin/lake` and the library's `.olean` files will be located in `.lake/build/lib`. + +### Building with Nix Flakes + +Lake is built as part of the main Lean 4 flake at the repository root. + +### Augmenting Lake's Search Path + +The `lake` executable needs to know where to find the Lean library files (e.g., `.olean`, `.ilean`) for the modules used in the package configuration file (and their source files for go-to-definition support in the editor). Lake will intelligently setup an initial search path based on the location of its own executable and `lean`. + +Specifically, if Lake is co-located with `lean` (i.e., there is `lean` executable in the same directory as itself), it will assume it was installed with Lean and that both Lean and Lake are located under their shared sysroot. In particular, their binaries are located in `/bin`, their Lean libraries in `/lib/lean`, Lean's source files in `/src/lean`, and Lake's source files in `/src/lean/lake`. Otherwise, it will run `lean --print-prefix` to find Lean's sysroot and assume that Lean's files are located as aforementioned, but that `lake` is at `/.lake/build/bin/lake` with its Lean libraries at `/.lake/build/lib` and its sources directly in ``. + +This search path can be augmented by including other directories of Lean libraries in the `LEAN_PATH` environment variable (and their sources in `LEAN_SRC_PATH`). This can allow the user to correct Lake's search when the files for Lean (or Lake itself) are in non-standard locations. However, such directories will *not* take precedence over the initial search path. This is important during development, as this prevents the Lake version used to build Lake from using the Lake version being built's Lean libraries (instead of its own) to elaborate Lake's `lakefile.lean` (which can lead to all kinds of errors). diff --git a/stage0/src/lakefile.toml.in b/stage0/src/lakefile.toml.in new file mode 100644 index 0000000000..d0fa6ad97d --- /dev/null +++ b/stage0/src/lakefile.toml.in @@ -0,0 +1,43 @@ +# This file allows lake to build Lean, Init, and Lake as Lean libraries. +# +# This is the file used when working with the stage0 compiler on the libraries +# +# It is not yet possible to build the compiler and other tooling executables with Lake; to build +# them, please consult the instructions in doc/dev/index.md. + +name = "lean4" + +defaultTargets = ["Init", "Lean", "Lake"] + +# The root of all the compiler output directories +buildDir = "${CMAKE_BINARY_DIR}" + +# The directory of Lean source files (i.e., `src`) +srcDir = "${LEAN_SOURCE_DIR}" + +# Destination C files and other intermediate representations +irDir = "lib/temp" + +# Destination for olean files +leanLibDir = "lib/lean" + +# Destination for static libraries +nativeLibDir = "lib/lean" + +[[lean_lib]] +name = "Init" + +[[lean_lib]] +name = "Lean" +globs = [ + # Library root + "Lean", + # Deliberate orphan file so `import Lean` does not induce an LLVM dependency + "Lean.Compiler.IR.EmitLLVM", + # New compiler orphan file used in tests + "Lean.Compiler.LCNF.Probing", +] + +[[lean_lib]] +name = "Lake" +srcDir = "lake" diff --git a/stage0/src/stdlib.make.in b/stage0/src/stdlib.make.in index dd4fbecc30..4d742ff78c 100644 --- a/stage0/src/stdlib.make.in +++ b/stage0/src/stdlib.make.in @@ -26,7 +26,7 @@ LEANMAKE_OPTS=\ CMAKE_LIKE_OUTPUT=1 ifeq "${STAGE}" "0" - LEANMAKE_OPTS+=C_ONLY=1 C_OUT=../stdlib/ + LEANMAKE_OPTS+=C_ONLY=1 C_OUT=${LEAN_SOURCE_DIR}/../stdlib/ endif .PHONY: Init Lean leanshared Lake lean @@ -41,7 +41,7 @@ Init: Lean: Init +"${LEAN_BIN}/leanmake" lib lib.export PKG=Lean $(LEANMAKE_OPTS) - + ${LIB}/temp/empty.c: touch $@ diff --git a/stage0/stdlib/Init/Data/Array/Basic.c b/stage0/stdlib/Init/Data/Array/Basic.c index be1ca5b2b1..291189020d 100644 --- a/stage0/stdlib/Init/Data/Array/Basic.c +++ b/stage0/stdlib/Init/Data/Array/Basic.c @@ -6372,7 +6372,7 @@ lean_object* x_7; lean_object* x_8; uint8_t x_9; x_7 = lean_array_uget(x_3, x_4); lean_inc(x_1); lean_inc(x_2); -x_8 = lean_apply_2(x_1, x_2, x_7); +x_8 = lean_apply_2(x_1, x_7, x_2); x_9 = lean_unbox(x_8); lean_dec(x_8); if (x_9 == 0) diff --git a/stage0/stdlib/Init/Data/Array/Lemmas.c b/stage0/stdlib/Init/Data/Array/Lemmas.c index 1dc811d393..57c575ccda 100644 --- a/stage0/stdlib/Init/Data/Array/Lemmas.c +++ b/stage0/stdlib/Init/Data/Array/Lemmas.c @@ -525,7 +525,7 @@ lean_object* x_7; lean_object* x_8; uint8_t x_9; x_7 = lean_array_uget(x_3, x_4); lean_inc(x_1); lean_inc(x_2); -x_8 = lean_apply_2(x_1, x_2, x_7); +x_8 = lean_apply_2(x_1, x_7, x_2); x_9 = lean_unbox(x_8); lean_dec(x_8); if (x_9 == 0) diff --git a/stage0/stdlib/Init/Data/BitVec/Basic.c b/stage0/stdlib/Init/Data/BitVec/Basic.c index 3e0ad42c4f..d233a80857 100644 --- a/stage0/stdlib/Init/Data/BitVec/Basic.c +++ b/stage0/stdlib/Init/Data/BitVec/Basic.c @@ -1773,7 +1773,7 @@ x_4 = lean_unsigned_to_nat(2u); x_5 = lean_nat_pow(x_4, x_1); x_6 = lean_nat_sub(x_5, x_3); lean_dec(x_5); -x_7 = lean_nat_add(x_2, x_6); +x_7 = lean_nat_add(x_6, x_2); lean_dec(x_6); x_8 = l_BitVec_ofNat(x_1, x_7); lean_dec(x_7); diff --git a/stage0/stdlib/Init/Data/Char/Lemmas.c b/stage0/stdlib/Init/Data/Char/Lemmas.c index 1089cae187..97f4dfa3da 100644 --- a/stage0/stdlib/Init/Data/Char/Lemmas.c +++ b/stage0/stdlib/Init/Data/Char/Lemmas.c @@ -13,6 +13,27 @@ #ifdef __cplusplus extern "C" { #endif +LEAN_EXPORT lean_object* l_String_csize(uint32_t); +LEAN_EXPORT lean_object* l_String_csize___boxed(lean_object*); +lean_object* l_Char_utf8Size(uint32_t); +LEAN_EXPORT lean_object* l_String_csize(uint32_t x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Char_utf8Size(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_String_csize___boxed(lean_object* x_1) { +_start: +{ +uint32_t x_2; lean_object* x_3; +x_2 = lean_unbox_uint32(x_1); +lean_dec(x_1); +x_3 = l_String_csize(x_2); +return x_3; +} +} lean_object* initialize_Init_Data_Char_Basic(uint8_t builtin, lean_object*); lean_object* initialize_Init_Data_UInt_Lemmas(uint8_t builtin, lean_object*); static bool _G_initialized = false; diff --git a/stage0/stdlib/Init/Data/Fin/Basic.c b/stage0/stdlib/Init/Data/Fin/Basic.c index bb4457becb..c936aa0f86 100644 --- a/stage0/stdlib/Init/Data/Fin/Basic.c +++ b/stage0/stdlib/Init/Data/Fin/Basic.c @@ -292,7 +292,7 @@ _start: { lean_object* x_4; lean_object* x_5; lean_object* x_6; x_4 = lean_nat_sub(x_1, x_3); -x_5 = lean_nat_add(x_2, x_4); +x_5 = lean_nat_add(x_4, x_2); lean_dec(x_4); x_6 = lean_nat_mod(x_5, x_1); lean_dec(x_5); diff --git a/stage0/stdlib/Init/Data/List/Basic.c b/stage0/stdlib/Init/Data/List/Basic.c index c8af616ba8..e7f71b5ba5 100644 --- a/stage0/stdlib/Init/Data/List/Basic.c +++ b/stage0/stdlib/Init/Data/List/Basic.c @@ -2632,7 +2632,7 @@ lean_inc(x_6); lean_dec(x_3); lean_inc(x_1); lean_inc(x_2); -x_7 = lean_apply_2(x_1, x_2, x_5); +x_7 = lean_apply_2(x_1, x_5, x_2); x_8 = lean_unbox(x_7); lean_dec(x_7); if (x_8 == 0) diff --git a/stage0/stdlib/Init/Data/String/Basic.c b/stage0/stdlib/Init/Data/String/Basic.c index 46ead93765..3fac0f5dfd 100644 --- a/stage0/stdlib/Init/Data/String/Basic.c +++ b/stage0/stdlib/Init/Data/String/Basic.c @@ -15,6 +15,7 @@ extern "C" { #endif LEAN_EXPORT lean_object* l_String_next_x27___boxed(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Substring_nextn___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3894____boxed(lean_object*, lean_object*); uint32_t lean_string_utf8_get_bang(lean_object*, lean_object*); lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_revFindAux(lean_object*, lean_object*, lean_object*); @@ -49,6 +50,7 @@ LEAN_EXPORT uint8_t l_String_Pos_isValid_go(lean_object*, lean_object*, lean_obj LEAN_EXPORT lean_object* l_String_toNat_x3f(lean_object*); LEAN_EXPORT lean_object* l_String_revPosOfAux___boxed(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_Iterator_remainingToString___boxed(lean_object*); +LEAN_EXPORT uint8_t l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3894_(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_append___boxed(lean_object*, lean_object*); LEAN_EXPORT uint8_t l_String_substrEq_loop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_splitAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -221,7 +223,6 @@ uint8_t lean_string_is_valid_pos(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_Iterator_atEnd___boxed(lean_object*); LEAN_EXPORT lean_object* l_Substring_takeWhileAux___at_Substring_trimLeft___spec__1(lean_object*, lean_object*, lean_object*); static lean_object* l_Substring_splitOn_loop___closed__2; -lean_object* l_String_csize(uint32_t); uint8_t l_Char_isDigit(uint32_t); LEAN_EXPORT lean_object* l_String_push___boxed(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Substring_nextn(lean_object*, lean_object*, lean_object*); @@ -236,7 +237,6 @@ LEAN_EXPORT lean_object* l___private_Init_Data_String_Basic_0__Substring_nextn_m LEAN_EXPORT lean_object* l_String_Iterator_forward(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_findAux(lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_replace(lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3629____boxed(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Substring_beq___boxed(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_Iterator_remainingBytes(lean_object*); LEAN_EXPORT lean_object* l_String_takeRightWhile___boxed(lean_object*, lean_object*); @@ -323,6 +323,7 @@ LEAN_EXPORT lean_object* l_Substring_splitOn(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_splitOn___boxed(lean_object*, lean_object*); uint8_t lean_nat_dec_le(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Substring_toIterator___boxed(lean_object*); +lean_object* l_Char_utf8Size(uint32_t); LEAN_EXPORT lean_object* l_String_nextWhile___boxed(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_findLineStart___lambda__1___boxed(lean_object*); lean_object* lean_nat_add(lean_object*, lean_object*); @@ -332,7 +333,6 @@ LEAN_EXPORT lean_object* l_Substring_foldl___rarg(lean_object*, lean_object*, le LEAN_EXPORT lean_object* l_String_foldl___rarg(lean_object*, lean_object*, lean_object*); uint8_t lean_string_dec_lt(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_extract_go_u2082___boxed(lean_object*, lean_object*, lean_object*); -LEAN_EXPORT uint8_t l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3629_(lean_object*, lean_object*); LEAN_EXPORT uint8_t l_String_anyAux___at_Substring_all___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_extract_go_u2081___boxed(lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_split(lean_object*, lean_object*); @@ -472,7 +472,7 @@ if (x_7 == 0) uint32_t x_8; lean_object* x_9; lean_object* x_10; x_8 = lean_unbox_uint32(x_5); lean_dec(x_5); -x_9 = l_String_csize(x_8); +x_9 = l_Char_utf8Size(x_8); x_10 = lean_nat_add(x_3, x_9); lean_dec(x_9); lean_dec(x_3); @@ -537,7 +537,7 @@ if (x_7 == 0) uint32_t x_8; lean_object* x_9; lean_object* x_10; x_8 = lean_unbox_uint32(x_5); lean_dec(x_5); -x_9 = l_String_csize(x_8); +x_9 = l_Char_utf8Size(x_8); x_10 = lean_nat_add(x_2, x_9); lean_dec(x_9); lean_dec(x_2); @@ -602,7 +602,7 @@ if (x_7 == 0) uint32_t x_8; lean_object* x_9; lean_object* x_10; x_8 = lean_unbox_uint32(x_5); lean_dec(x_5); -x_9 = l_String_csize(x_8); +x_9 = l_Char_utf8Size(x_8); x_10 = lean_nat_add(x_2, x_9); lean_dec(x_9); lean_dec(x_2); @@ -675,7 +675,7 @@ if (x_9 == 0) { uint32_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; x_10 = lean_unbox_uint32(x_7); -x_11 = l_String_csize(x_10); +x_11 = l_Char_utf8Size(x_10); x_12 = lean_nat_add(x_3, x_11); lean_dec(x_11); x_13 = l_String_utf8SetAux(x_1, x_8, x_12, x_4); @@ -705,7 +705,7 @@ if (x_17 == 0) { uint32_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; x_18 = lean_unbox_uint32(x_15); -x_19 = l_String_csize(x_18); +x_19 = l_Char_utf8Size(x_18); x_20 = lean_nat_add(x_3, x_19); lean_dec(x_19); x_21 = l_String_utf8SetAux(x_1, x_16, x_20, x_4); @@ -804,7 +804,7 @@ lean_inc(x_6); lean_dec(x_1); x_7 = lean_unbox_uint32(x_5); lean_dec(x_5); -x_8 = l_String_csize(x_7); +x_8 = l_Char_utf8Size(x_7); x_9 = lean_nat_add(x_2, x_8); lean_dec(x_8); x_10 = lean_nat_dec_eq(x_9, x_3); @@ -1338,7 +1338,7 @@ if (x_8 == 0) { uint32_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; x_9 = lean_unbox_uint32(x_6); -x_10 = l_String_csize(x_9); +x_10 = l_Char_utf8Size(x_9); x_11 = lean_nat_add(x_2, x_10); lean_dec(x_10); x_12 = l_String_extract_go_u2082(x_7, x_11, x_3); @@ -1369,7 +1369,7 @@ if (x_16 == 0) { uint32_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; x_17 = lean_unbox_uint32(x_14); -x_18 = l_String_csize(x_17); +x_18 = l_Char_utf8Size(x_17); x_19 = lean_nat_add(x_2, x_18); lean_dec(x_18); x_20 = l_String_extract_go_u2082(x_15, x_19, x_3); @@ -1425,7 +1425,7 @@ uint32_t x_9; lean_object* x_10; lean_object* x_11; lean_dec(x_1); x_9 = lean_unbox_uint32(x_6); lean_dec(x_6); -x_10 = l_String_csize(x_9); +x_10 = l_Char_utf8Size(x_9); x_11 = lean_nat_add(x_2, x_10); lean_dec(x_10); lean_dec(x_2); @@ -1917,7 +1917,7 @@ lean_dec(x_1); return x_3; } } -LEAN_EXPORT uint8_t l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3629_(lean_object* x_1, lean_object* x_2) { +LEAN_EXPORT uint8_t l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3894_(lean_object* x_1, lean_object* x_2) { _start: { lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; @@ -1940,11 +1940,11 @@ return x_9; } } } -LEAN_EXPORT lean_object* l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3629____boxed(lean_object* x_1, lean_object* x_2) { +LEAN_EXPORT lean_object* l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3894____boxed(lean_object* x_1, lean_object* x_2) { _start: { uint8_t x_3; lean_object* x_4; -x_3 = l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3629_(x_1, x_2); +x_3 = l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3894_(x_1, x_2); lean_dec(x_2); lean_dec(x_1); x_4 = lean_box(x_3); @@ -1955,7 +1955,7 @@ LEAN_EXPORT uint8_t l_String_instDecidableEqIterator(lean_object* x_1, lean_obje _start: { uint8_t x_3; -x_3 = l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3629_(x_1, x_2); +x_3 = l___private_Init_Data_String_Basic_0__String_decEqIterator____x40_Init_Data_String_Basic___hyg_3894_(x_1, x_2); return x_3; } } @@ -3130,11 +3130,11 @@ return x_11; else { lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; -x_12 = l_String_csize(x_8); +x_12 = l_Char_utf8Size(x_8); x_13 = lean_nat_add(x_3, x_12); lean_dec(x_12); lean_dec(x_3); -x_14 = l_String_csize(x_9); +x_14 = l_Char_utf8Size(x_9); x_15 = lean_nat_add(x_4, x_14); lean_dec(x_14); lean_dec(x_4); diff --git a/stage0/stdlib/Init/Data/String/Extra.c b/stage0/stdlib/Init/Data/String/Extra.c index edca6a768c..f52d8c197e 100644 --- a/stage0/stdlib/Init/Data/String/Extra.c +++ b/stage0/stdlib/Init/Data/String/Extra.c @@ -99,7 +99,6 @@ static lean_object* l_String___aux__Init__Data__String__Extra______macroRules__t static lean_object* l_String___aux__Init__Data__String__Extra______macroRules__tacticDecreasing__trivial__1___closed__20; LEAN_EXPORT lean_object* l___private_Init_Data_String_Extra_0__String_removeNumLeadingSpaces_consumeSpaces(lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_String_validateUTF8___boxed(lean_object*); -lean_object* l_String_csize(uint32_t); static lean_object* l_String___aux__Init__Data__String__Extra______macroRules__tacticDecreasing__trivial__1___closed__12; LEAN_EXPORT lean_object* l_String_toNat_x21___boxed(lean_object*); LEAN_EXPORT lean_object* l_String_fromUTF8_x21___boxed(lean_object*); @@ -144,6 +143,7 @@ static lean_object* l_String___aux__Init__Data__String__Extra______macroRules__t LEAN_EXPORT lean_object* l_String_validateUTF8_loop___boxed(lean_object*, lean_object*); uint8_t lean_nat_dec_le(lean_object*, lean_object*); static uint8_t l_String_crlfToLf_go___closed__1; +lean_object* l_Char_utf8Size(uint32_t); lean_object* lean_nat_add(lean_object*, lean_object*); static lean_object* l_String___aux__Init__Data__String__Extra______macroRules__tacticDecreasing__trivial__2___closed__6; lean_object* lean_byte_array_size(lean_object*); @@ -685,7 +685,7 @@ lean_inc(x_8); lean_dec(x_6); x_9 = lean_unbox_uint32(x_8); lean_dec(x_8); -x_10 = l_String_csize(x_9); +x_10 = l_Char_utf8Size(x_9); x_11 = lean_nat_add(x_2, x_10); lean_dec(x_10); lean_dec(x_2); @@ -719,7 +719,7 @@ _start: { uint32_t x_1; lean_object* x_2; x_1 = 65; -x_2 = l_String_csize(x_1); +x_2 = l_Char_utf8Size(x_1); return x_2; } } @@ -758,7 +758,7 @@ x_12 = lean_ctor_get(x_6, 0); lean_inc(x_12); lean_dec(x_6); x_13 = lean_unbox_uint32(x_12); -x_14 = l_String_csize(x_13); +x_14 = l_Char_utf8Size(x_13); x_15 = lean_nat_add(x_2, x_14); lean_dec(x_14); lean_dec(x_2); diff --git a/stage0/stdlib/Init/Meta.c b/stage0/stdlib/Init/Meta.c index d1f3c9cdf5..8132eeca47 100644 --- a/stage0/stdlib/Init/Meta.c +++ b/stage0/stdlib/Init/Meta.c @@ -21581,7 +21581,7 @@ else lean_object* x_4; lean_object* x_5; uint8_t x_6; x_4 = lean_ctor_get(x_2, 0); x_5 = lean_ctor_get(x_2, 1); -x_6 = lean_nat_dec_eq(x_1, x_4); +x_6 = lean_nat_dec_eq(x_4, x_1); if (x_6 == 0) { x_2 = x_5; diff --git a/stage0/stdlib/Init/Prelude.c b/stage0/stdlib/Init/Prelude.c index 87ef38ee5b..3b26516db3 100644 --- a/stage0/stdlib/Init/Prelude.c +++ b/stage0/stdlib/Init/Prelude.c @@ -320,7 +320,6 @@ LEAN_EXPORT lean_object* l_String_utf8ByteSize___boxed(lean_object*); static lean_object* l_Lean_Macro_instMonadQuotationMacroM___closed__1; LEAN_EXPORT lean_object* l_id(lean_object*); LEAN_EXPORT lean_object* l_UInt8_ofNatCore___boxed(lean_object*, lean_object*); -static uint32_t l_Char_utf8Size___closed__4; LEAN_EXPORT lean_object* l_Lean_Name_mkStr7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_EStateM_set___rarg(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Macro_instMonadRefMacroM___lambda__1___boxed(lean_object*, lean_object*, lean_object*); @@ -380,7 +379,6 @@ LEAN_EXPORT lean_object* l___private_Init_Prelude_0__Lean_extractImported(lean_o LEAN_EXPORT lean_object* l_tryCatchThe(lean_object*, lean_object*); static lean_object* l_EStateM_nonBacktrackable___closed__2; LEAN_EXPORT uint8_t l_Fin_decLt___rarg(lean_object*, lean_object*); -static uint32_t l_Char_utf8Size___closed__7; LEAN_EXPORT lean_object* l_List_foldl(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Macro_throwError___rarg___boxed(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_mk___boxed(lean_object*, lean_object*); @@ -480,7 +478,6 @@ LEAN_EXPORT uint8_t l_instDecidableLtPos(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_ReaderT_instMonadLift___rarg(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_unsafeCast(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_MonadExcept_orElse___rarg(lean_object*, lean_object*, lean_object*, lean_object*); -static uint32_t l_Char_utf8Size___closed__6; static lean_object* l_Array_mkArray3___rarg___closed__1; LEAN_EXPORT lean_object* l_List_lengthTRAux___rarg(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_System_Platform_numBits; @@ -586,7 +583,6 @@ LEAN_EXPORT lean_object* l_EStateM_instInhabited(lean_object*, lean_object*, lea LEAN_EXPORT uint8_t l_Decidable_decide___rarg(uint8_t); LEAN_EXPORT lean_object* l_Lean_Syntax_matchesLit___boxed(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Macro_instInhabitedMethods___lambda__1___boxed(lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_String_csize(uint32_t); static lean_object* l_Lean_interpolatedStrLitKind___closed__2; LEAN_EXPORT lean_object* l_inferInstance___rarg(lean_object*); LEAN_EXPORT lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*); @@ -682,7 +678,6 @@ LEAN_EXPORT lean_object* l_ReaderT_instFunctorOfMonad___rarg(lean_object*); LEAN_EXPORT lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_instAddNat; uint32_t lean_uint32_of_nat(lean_object*); -static uint32_t l_Char_utf8Size___closed__5; LEAN_EXPORT lean_object* l_instHMod___rarg(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Fin_decLt___rarg___boxed(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Macro_instMonadQuotationMacroM___lambda__2___boxed(lean_object*, lean_object*); @@ -817,7 +812,6 @@ LEAN_EXPORT lean_object* l_Array_extract___rarg___boxed(lean_object*, lean_objec LEAN_EXPORT lean_object* l_ReaderT_instApplicativeOfMonad(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_List_redLength___rarg(lean_object*); static lean_object* l_instAddNat___closed__1; -LEAN_EXPORT lean_object* l_String_csize___boxed(lean_object*); LEAN_EXPORT lean_object* l_Lean_Syntax_getTailPos_x3f_loop(uint8_t, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_getModify___rarg___lambda__1(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Monad_seqLeft___default___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*); @@ -863,7 +857,7 @@ LEAN_EXPORT lean_object* l_instMonadFunctorTOfMonadFunctor___rarg___lambda__2(le static lean_object* l_EStateM_instMonadStateOf___closed__2; LEAN_EXPORT lean_object* l_Array_data___boxed(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_mkArray2___rarg(lean_object*, lean_object*); -LEAN_EXPORT uint32_t l_Char_utf8Size(uint32_t); +LEAN_EXPORT lean_object* l_Char_utf8Size(uint32_t); LEAN_EXPORT lean_object* l_letFun(lean_object*, lean_object*); static lean_object* l_Lean_Macro_instInhabitedMethods___closed__3; LEAN_EXPORT lean_object* l_Lean_hygieneInfoKind; @@ -3299,43 +3293,7 @@ x_2 = lean_uint32_of_nat(x_1); return x_2; } } -static uint32_t _init_l_Char_utf8Size___closed__4() { -_start: -{ -lean_object* x_1; uint32_t x_2; -x_1 = lean_unsigned_to_nat(4u); -x_2 = lean_uint32_of_nat(x_1); -return x_2; -} -} -static uint32_t _init_l_Char_utf8Size___closed__5() { -_start: -{ -lean_object* x_1; uint32_t x_2; -x_1 = lean_unsigned_to_nat(3u); -x_2 = lean_uint32_of_nat(x_1); -return x_2; -} -} -static uint32_t _init_l_Char_utf8Size___closed__6() { -_start: -{ -lean_object* x_1; uint32_t x_2; -x_1 = lean_unsigned_to_nat(2u); -x_2 = lean_uint32_of_nat(x_1); -return x_2; -} -} -static uint32_t _init_l_Char_utf8Size___closed__7() { -_start: -{ -lean_object* x_1; uint32_t x_2; -x_1 = lean_unsigned_to_nat(1u); -x_2 = lean_uint32_of_nat(x_1); -return x_2; -} -} -LEAN_EXPORT uint32_t l_Char_utf8Size(uint32_t x_1) { +LEAN_EXPORT lean_object* l_Char_utf8Size(uint32_t x_1) { _start: { uint32_t x_2; uint8_t x_3; @@ -3353,28 +3311,28 @@ x_6 = l_Char_utf8Size___closed__3; x_7 = lean_uint32_dec_le(x_1, x_6); if (x_7 == 0) { -uint32_t x_8; -x_8 = l_Char_utf8Size___closed__4; +lean_object* x_8; +x_8 = lean_unsigned_to_nat(4u); return x_8; } else { -uint32_t x_9; -x_9 = l_Char_utf8Size___closed__5; +lean_object* x_9; +x_9 = lean_unsigned_to_nat(3u); return x_9; } } else { -uint32_t x_10; -x_10 = l_Char_utf8Size___closed__6; +lean_object* x_10; +x_10 = lean_unsigned_to_nat(2u); return x_10; } } else { -uint32_t x_11; -x_11 = l_Char_utf8Size___closed__7; +lean_object* x_11; +x_11 = lean_unsigned_to_nat(1u); return x_11; } } @@ -3382,12 +3340,11 @@ return x_11; LEAN_EXPORT lean_object* l_Char_utf8Size___boxed(lean_object* x_1) { _start: { -uint32_t x_2; uint32_t x_3; lean_object* x_4; +uint32_t x_2; lean_object* x_3; x_2 = lean_unbox_uint32(x_1); lean_dec(x_1); x_3 = l_Char_utf8Size(x_2); -x_4 = lean_box_uint32(x_3); -return x_4; +return x_3; } } LEAN_EXPORT lean_object* l_instInhabitedOption(lean_object* x_1) { @@ -4037,25 +3994,6 @@ lean_dec(x_1); return x_2; } } -LEAN_EXPORT lean_object* l_String_csize(uint32_t x_1) { -_start: -{ -uint32_t x_2; lean_object* x_3; -x_2 = l_Char_utf8Size(x_1); -x_3 = lean_uint32_to_nat(x_2); -return x_3; -} -} -LEAN_EXPORT lean_object* l_String_csize___boxed(lean_object* x_1) { -_start: -{ -uint32_t x_2; lean_object* x_3; -x_2 = lean_unbox_uint32(x_1); -lean_dec(x_1); -x_3 = l_String_csize(x_2); -return x_3; -} -} LEAN_EXPORT lean_object* l_String_utf8ByteSize_go(lean_object* x_1) { _start: { @@ -4076,7 +4014,7 @@ lean_dec(x_1); x_5 = l_String_utf8ByteSize_go(x_4); x_6 = lean_unbox_uint32(x_3); lean_dec(x_3); -x_7 = l_String_csize(x_6); +x_7 = l_Char_utf8Size(x_6); x_8 = lean_nat_add(x_5, x_7); lean_dec(x_7); lean_dec(x_5); @@ -4133,7 +4071,7 @@ LEAN_EXPORT lean_object* l_instHAddPosChar(lean_object* x_1, uint32_t x_2) { _start: { lean_object* x_3; lean_object* x_4; -x_3 = l_String_csize(x_2); +x_3 = l_Char_utf8Size(x_2); x_4 = lean_nat_add(x_1, x_3); lean_dec(x_3); return x_4; @@ -12332,10 +12270,6 @@ lean_mark_persistent(l_Char_ofNat___closed__1); l_Char_utf8Size___closed__1 = _init_l_Char_utf8Size___closed__1(); l_Char_utf8Size___closed__2 = _init_l_Char_utf8Size___closed__2(); l_Char_utf8Size___closed__3 = _init_l_Char_utf8Size___closed__3(); -l_Char_utf8Size___closed__4 = _init_l_Char_utf8Size___closed__4(); -l_Char_utf8Size___closed__5 = _init_l_Char_utf8Size___closed__5(); -l_Char_utf8Size___closed__6 = _init_l_Char_utf8Size___closed__6(); -l_Char_utf8Size___closed__7 = _init_l_Char_utf8Size___closed__7(); l_String_Pos_byteIdx___default = _init_l_String_Pos_byteIdx___default(); lean_mark_persistent(l_String_Pos_byteIdx___default); l_instInhabitedPos = _init_l_instInhabitedPos(); diff --git a/stage0/stdlib/Init/System/FilePath.c b/stage0/stdlib/Init/System/FilePath.c index e2a64f2609..71e3a3cf75 100644 --- a/stage0/stdlib/Init/System/FilePath.c +++ b/stage0/stdlib/Init/System/FilePath.c @@ -88,7 +88,6 @@ LEAN_EXPORT uint32_t l_System_FilePath_pathSeparator; LEAN_EXPORT lean_object* l_System_FilePath_isAbsolute___boxed(lean_object*); static lean_object* l_System_FilePath_parent___closed__3; lean_object* l_String_revPosOf(lean_object*, uint32_t); -lean_object* l_String_csize(uint32_t); static lean_object* l_System_FilePath_fileName___closed__3; LEAN_EXPORT lean_object* l_System_mkFilePath(lean_object*); LEAN_EXPORT uint8_t l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_System_FilePath_parent___spec__1(lean_object*, lean_object*); @@ -125,6 +124,7 @@ LEAN_EXPORT lean_object* l_List_mapTR_loop___at_System_SearchPath_parse___spec__ lean_object* lean_string_append(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_System_FilePath_normalize___lambda__1(lean_object*, lean_object*); uint8_t lean_nat_dec_le(lean_object*, lean_object*); +lean_object* l_Char_utf8Size(uint32_t); static lean_object* l_System_FilePath_fileName___closed__2; lean_object* lean_nat_add(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_System_FilePath_instHDivString(lean_object*, lean_object*); @@ -442,7 +442,7 @@ lean_inc(x_5); lean_dec(x_2); x_6 = lean_unbox_uint32(x_4); lean_dec(x_4); -x_7 = lean_uint32_dec_eq(x_1, x_6); +x_7 = lean_uint32_dec_eq(x_6, x_1); if (x_7 == 0) { x_2 = x_5; @@ -1085,7 +1085,7 @@ _start: { uint32_t x_1; lean_object* x_2; x_1 = 47; -x_2 = l_String_csize(x_1); +x_2 = l_Char_utf8Size(x_1); return x_2; } } @@ -1403,7 +1403,7 @@ _start: { uint32_t x_1; lean_object* x_2; x_1 = 46; -x_2 = l_String_csize(x_1); +x_2 = l_Char_utf8Size(x_1); return x_2; } } diff --git a/stage0/stdlib/Lake.c b/stage0/stdlib/Lake.c new file mode 100644 index 0000000000..1670b4209b --- /dev/null +++ b/stage0/stdlib/Lake.c @@ -0,0 +1,53 @@ +// Lean compiler output +// Module: Lake +// Imports: Init Lake.Build Lake.Config Lake.DSL Lake.Version Lake.CLI.Actions Lake.Toml +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Config(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_DSL(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Version(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_CLI_Actions(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Toml(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Config(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_DSL(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Version(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_CLI_Actions(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Toml(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build.c b/stage0/stdlib/Lake/Build.c new file mode 100644 index 0000000000..ed56f4e8d0 --- /dev/null +++ b/stage0/stdlib/Lake/Build.c @@ -0,0 +1,53 @@ +// Lean compiler output +// Module: Lake.Build +// Imports: Init Lake.Build.Run Lake.Build.Module Lake.Build.Package Lake.Build.Library Lake.Build.Imports Lake.Build.Targets +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Run(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Module(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Package(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Library(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Imports(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Targets(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Run(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Module(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Package(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Library(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Imports(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Targets(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Actions.c b/stage0/stdlib/Lake/Build/Actions.c new file mode 100644 index 0000000000..024cf7cd38 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Actions.c @@ -0,0 +1,5095 @@ +// Lean compiler output +// Module: Lake.Build.Actions +// Imports: Init Lake.Util.Proc Lake.Util.NativeLib Lake.Util.IO +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_tar___closed__1; +static lean_object* l_Lake_compileLeanModule___lambda__4___closed__2; +LEAN_EXPORT lean_object* l_Lake_compileO(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__23; +static lean_object* l_Lake_tar___lambda__1___closed__2; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__3; +static lean_object* l_Lake_compileSharedLib___closed__1; +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__35; +static lean_object* l_Lake_tar___lambda__1___closed__5; +lean_object* lean_uint32_to_nat(uint32_t); +lean_object* lean_io_remove_file(lean_object*, lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__5___closed__1; +lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__4(lean_object*, lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__3; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__19; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__4; +LEAN_EXPORT lean_object* l_Lake_compileSharedLib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__31; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +static lean_object* l_Lake_compileLeanModule___lambda__4___closed__1; +extern uint8_t l_System_Platform_isOSX; +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__6; +static lean_object* l_Lake_download___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_untar___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__32; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__1; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_String_trim(lean_object*); +LEAN_EXPORT lean_object* l_Lake_download(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__3___closed__2; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__5; +static lean_object* l_Lake_compileLeanModule___lambda__6___closed__1; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__41; +static lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2; +lean_object* l_Lean_mkErrorStringWithPos(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__5(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__2; +lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__2(lean_object*, lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__7; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_tar___lambda__1___closed__1; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__37; +lean_object* l_System_FilePath_pathExists(lean_object*, lean_object*); +lean_object* lean_string_push(lean_object*, uint32_t); +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileExe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_untar___lambda__1___closed__3; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__40; +lean_object* l_IO_FS_createDirAll(lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__10; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__28; +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_appendTR___rarg(lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__36; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__34; +size_t lean_usize_of_nat(lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileSharedLib___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__4; +uint8_t l_String_isEmpty(lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__12; +static lean_object* l_Lake_tar___lambda__1___closed__3; +static lean_object* l_Lake_compileLeanModule___closed__2; +uint8_t l_instDecidableNot___rarg(uint8_t); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__15; +lean_object* l_String_split___at_Lean_stringToMessageData___spec__1(lean_object*); +lean_object* l_Lake_createParentDirs(lean_object*, lean_object*); +static lean_object* l_Lake_tar___closed__4; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__13; +static lean_object* l_Lake_compileSharedLib___closed__2; +static lean_object* l_Lake_untar___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_tar___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__20; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__5; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__18; +static lean_object* l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__1; +lean_object* l_Lake_mkCmdLog(lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__9; +static lean_object* l_Lake_compileLeanModule___lambda__5___closed__2; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lake_LogLevel_ofMessageSeverity(uint8_t); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__9; +lean_object* l_IO_Process_output(lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__17; +static lean_object* l_Lake_tar___closed__2; +LEAN_EXPORT lean_object* l_Lake_untar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_untar___lambda__1___closed__2; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__14; +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__22; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__38; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +static lean_object* l_Lake_untar___closed__2; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__27; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(size_t, size_t, lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__7___closed__2; +LEAN_EXPORT lean_object* l_Lake_untar(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +lean_object* l_Lake_getSearchPath(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_download___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_tar___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_untar___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__42; +lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileO___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_compileStaticLib___closed__1; +static lean_object* l_Lake_compileSharedLib___closed__3; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__25; +LEAN_EXPORT lean_object* l_Lake_download___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__30; +static lean_object* l_Lake_tar___closed__5; +static lean_object* l_Lake_compileLeanModule___lambda__4___closed__4; +static lean_object* l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___closed__1; +static lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +static lean_object* l_Lake_compileO___closed__1; +lean_object* l_System_SearchPath_toString(lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_uint32_dec_eq(uint32_t, uint32_t); +static lean_object* l_Lake_compileLeanModule___lambda__1___closed__1; +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_tar(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__3___closed__1; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__26; +LEAN_EXPORT lean_object* l_Lake_compileExe___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_tar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__10; +static lean_object* l_Lake_compileLeanModule___closed__4; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__39; +static lean_object* l_Lake_compileO___closed__2; +static lean_object* l_Lake_compileLeanModule___closed__3; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__33; +extern lean_object* l_Lake_sharedLibPathEnvVar; +lean_object* l_Lake_proc(lean_object*, uint8_t, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__21; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__8; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_tar___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__29; +lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__3(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +size_t lean_usize_add(size_t, size_t); +static lean_object* l_Lake_download___lambda__1___closed__8; +static lean_object* l_Lake_compileLeanModule___closed__1; +lean_object* lean_array_uget(lean_object*, size_t); +LEAN_EXPORT lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2(lean_object*); +static lean_object* l_Lake_download___lambda__1___closed__6; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileStaticLib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_error_to_string(lean_object*); +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__2; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__16; +static lean_object* l_Lake_tar___closed__3; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__7___closed__1; +lean_object* lean_array_get_size(lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__4___closed__3; +uint8_t lean_usize_dec_lt(size_t, size_t); +static lean_object* l_Lake_compileStaticLib___closed__2; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Json_parse(lean_object*); +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_compileO___closed__4; +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__2___closed__1; +lean_object* lean_array_uset(lean_object*, size_t, lean_object*); +lean_object* l___private_Init_Data_Repr_0__Nat_reprFast(lean_object*); +static lean_object* l_Lake_untar___closed__1; +static lean_object* l_Lake_compileO___closed__3; +static lean_object* l_Lake_tar___lambda__1___closed__4; +static lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__24; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_compileLeanModule___lambda__6___closed__2; +static lean_object* l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3___closed__1; +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("--load-dynlib=", 14); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = lean_usize_dec_lt(x_3, x_2); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_4); +lean_ctor_set(x_8, 1, x_5); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_6); +return x_9; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; +x_10 = lean_array_uget(x_1, x_3); +x_11 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__1; +x_12 = lean_string_append(x_11, x_10); +lean_dec(x_10); +x_13 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_14 = lean_string_append(x_12, x_13); +x_15 = lean_array_push(x_4, x_14); +x_16 = 1; +x_17 = lean_usize_add(x_3, x_16); +x_3 = x_17; +x_4 = x_15; +goto _start; +} +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("fileName", 8); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lean", 4); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("BaseMessage", 11); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__2; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__3; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__5() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__4; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(".", 1); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__5; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__6; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__9() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__8; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__9; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": ", 2); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__10; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__13() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("pos", 3); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__13; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__15() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__14; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__16() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__15; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__16; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__18() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("endPos", 6); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__19() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__18; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__20() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__19; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__21() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__20; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__22() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__21; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__23() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("keepFullRange", 13); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__24() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__23; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__25() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__24; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__26() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__25; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__27() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__26; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__28() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("severity", 8); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__29() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__28; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__30() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__29; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__31() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__30; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__32() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__31; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__33() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("caption", 7); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__34() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__33; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__35() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__34; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__36() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__35; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__37() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__36; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__38() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("data", 4); +return x_1; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__39() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__38; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__40() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__39; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__41() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__40; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__42() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__41; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__1; +lean_inc(x_1); +x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__1(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +lean_dec(x_1); +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_3, 0); +x_6 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__12; +x_7 = lean_string_append(x_6, x_5); +lean_dec(x_5); +lean_ctor_set(x_3, 0, x_7); +return x_3; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_3, 0); +lean_inc(x_8); +lean_dec(x_3); +x_9 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__12; +x_10 = lean_string_append(x_9, x_8); +lean_dec(x_8); +x_11 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_11, 0, x_10); +return x_11; +} +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_3, 0); +lean_inc(x_12); +lean_dec(x_3); +x_13 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__13; +lean_inc(x_1); +x_14 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__2(x_1, x_13); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +lean_dec(x_12); +lean_dec(x_1); +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 0); +x_17 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__17; +x_18 = lean_string_append(x_17, x_16); +lean_dec(x_16); +lean_ctor_set(x_14, 0, x_18); +return x_14; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_14, 0); +lean_inc(x_19); +lean_dec(x_14); +x_20 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__17; +x_21 = lean_string_append(x_20, x_19); +lean_dec(x_19); +x_22 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_22, 0, x_21); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_14, 0); +lean_inc(x_23); +lean_dec(x_14); +x_24 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__18; +lean_inc(x_1); +x_25 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__3(x_1, x_24); +if (lean_obj_tag(x_25) == 0) +{ +uint8_t x_26; +lean_dec(x_23); +lean_dec(x_12); +lean_dec(x_1); +x_26 = !lean_is_exclusive(x_25); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_25, 0); +x_28 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__22; +x_29 = lean_string_append(x_28, x_27); +lean_dec(x_27); +lean_ctor_set(x_25, 0, x_29); +return x_25; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_25, 0); +lean_inc(x_30); +lean_dec(x_25); +x_31 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__22; +x_32 = lean_string_append(x_31, x_30); +lean_dec(x_30); +x_33 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_33, 0, x_32); +return x_33; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_25, 0); +lean_inc(x_34); +lean_dec(x_25); +x_35 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__23; +lean_inc(x_1); +x_36 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__4(x_1, x_35); +if (lean_obj_tag(x_36) == 0) +{ +uint8_t x_37; +lean_dec(x_34); +lean_dec(x_23); +lean_dec(x_12); +lean_dec(x_1); +x_37 = !lean_is_exclusive(x_36); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_36, 0); +x_39 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__27; +x_40 = lean_string_append(x_39, x_38); +lean_dec(x_38); +lean_ctor_set(x_36, 0, x_40); +return x_36; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_41 = lean_ctor_get(x_36, 0); +lean_inc(x_41); +lean_dec(x_36); +x_42 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__27; +x_43 = lean_string_append(x_42, x_41); +lean_dec(x_41); +x_44 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_44, 0, x_43); +return x_44; +} +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_36, 0); +lean_inc(x_45); +lean_dec(x_36); +x_46 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__28; +lean_inc(x_1); +x_47 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__5(x_1, x_46); +if (lean_obj_tag(x_47) == 0) +{ +uint8_t x_48; +lean_dec(x_45); +lean_dec(x_34); +lean_dec(x_23); +lean_dec(x_12); +lean_dec(x_1); +x_48 = !lean_is_exclusive(x_47); +if (x_48 == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_47, 0); +x_50 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__32; +x_51 = lean_string_append(x_50, x_49); +lean_dec(x_49); +lean_ctor_set(x_47, 0, x_51); +return x_47; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_47, 0); +lean_inc(x_52); +lean_dec(x_47); +x_53 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__32; +x_54 = lean_string_append(x_53, x_52); +lean_dec(x_52); +x_55 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_55, 0, x_54); +return x_55; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_47, 0); +lean_inc(x_56); +lean_dec(x_47); +x_57 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__33; +lean_inc(x_1); +x_58 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__1(x_1, x_57); +if (lean_obj_tag(x_58) == 0) +{ +uint8_t x_59; +lean_dec(x_56); +lean_dec(x_45); +lean_dec(x_34); +lean_dec(x_23); +lean_dec(x_12); +lean_dec(x_1); +x_59 = !lean_is_exclusive(x_58); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_60 = lean_ctor_get(x_58, 0); +x_61 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__37; +x_62 = lean_string_append(x_61, x_60); +lean_dec(x_60); +lean_ctor_set(x_58, 0, x_62); +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_63 = lean_ctor_get(x_58, 0); +lean_inc(x_63); +lean_dec(x_58); +x_64 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__37; +x_65 = lean_string_append(x_64, x_63); +lean_dec(x_63); +x_66 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_66, 0, x_65); +return x_66; +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_58, 0); +lean_inc(x_67); +lean_dec(x_58); +x_68 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__38; +x_69 = l_Lean_Json_getObjValAs_x3f___at___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____spec__1(x_1, x_68); +if (lean_obj_tag(x_69) == 0) +{ +uint8_t x_70; +lean_dec(x_67); +lean_dec(x_56); +lean_dec(x_45); +lean_dec(x_34); +lean_dec(x_23); +lean_dec(x_12); +x_70 = !lean_is_exclusive(x_69); +if (x_70 == 0) +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_71 = lean_ctor_get(x_69, 0); +x_72 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__42; +x_73 = lean_string_append(x_72, x_71); +lean_dec(x_71); +lean_ctor_set(x_69, 0, x_73); +return x_69; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_74 = lean_ctor_get(x_69, 0); +lean_inc(x_74); +lean_dec(x_69); +x_75 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__42; +x_76 = lean_string_append(x_75, x_74); +lean_dec(x_74); +x_77 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_77, 0, x_76); +return x_77; +} +} +else +{ +uint8_t x_78; +x_78 = !lean_is_exclusive(x_69); +if (x_78 == 0) +{ +lean_object* x_79; lean_object* x_80; uint8_t x_81; uint8_t x_82; +x_79 = lean_ctor_get(x_69, 0); +x_80 = lean_alloc_ctor(0, 5, 2); +lean_ctor_set(x_80, 0, x_12); +lean_ctor_set(x_80, 1, x_23); +lean_ctor_set(x_80, 2, x_34); +lean_ctor_set(x_80, 3, x_67); +lean_ctor_set(x_80, 4, x_79); +x_81 = lean_unbox(x_45); +lean_dec(x_45); +lean_ctor_set_uint8(x_80, sizeof(void*)*5, x_81); +x_82 = lean_unbox(x_56); +lean_dec(x_56); +lean_ctor_set_uint8(x_80, sizeof(void*)*5 + 1, x_82); +lean_ctor_set(x_69, 0, x_80); +return x_69; +} +else +{ +lean_object* x_83; lean_object* x_84; uint8_t x_85; uint8_t x_86; lean_object* x_87; +x_83 = lean_ctor_get(x_69, 0); +lean_inc(x_83); +lean_dec(x_69); +x_84 = lean_alloc_ctor(0, 5, 2); +lean_ctor_set(x_84, 0, x_12); +lean_ctor_set(x_84, 1, x_23); +lean_ctor_set(x_84, 2, x_34); +lean_ctor_set(x_84, 3, x_67); +lean_ctor_set(x_84, 4, x_83); +x_85 = lean_unbox(x_45); +lean_dec(x_45); +lean_ctor_set_uint8(x_84, sizeof(void*)*5, x_85); +x_86 = lean_unbox(x_56); +lean_dec(x_56); +lean_ctor_set_uint8(x_84, sizeof(void*)*5 + 1, x_86); +x_87 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_87, 0, x_84); +return x_87; +} +} +} +} +} +} +} +} +} +} +static lean_object* _init_l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":\n", 2); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_4 = lean_ctor_get(x_1, 3); +lean_inc(x_4); +x_5 = l_String_trim(x_4); +lean_dec(x_4); +x_6 = l_String_isEmpty(x_5); +x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*5 + 1); +x_8 = l_Lake_LogLevel_ofMessageSeverity(x_7); +x_9 = lean_ctor_get(x_1, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_1, 1); +lean_inc(x_10); +x_11 = lean_box(0); +if (x_6 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_12 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_13 = lean_string_append(x_12, x_5); +lean_dec(x_5); +x_14 = l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3___closed__1; +x_15 = lean_string_append(x_13, x_14); +x_16 = lean_ctor_get(x_1, 4); +lean_inc(x_16); +lean_dec(x_1); +x_17 = l_String_trim(x_16); +lean_dec(x_16); +x_18 = lean_string_append(x_15, x_17); +lean_dec(x_17); +x_19 = lean_string_append(x_18, x_12); +x_20 = l_Lean_mkErrorStringWithPos(x_9, x_10, x_19, x_11); +lean_dec(x_19); +lean_dec(x_9); +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_8); +x_22 = lean_array_push(x_2, x_21); +x_23 = lean_box(0); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_3); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_5); +x_26 = lean_ctor_get(x_1, 4); +lean_inc(x_26); +lean_dec(x_1); +x_27 = l_String_trim(x_26); +lean_dec(x_26); +x_28 = l_Lean_mkErrorStringWithPos(x_9, x_10, x_27, x_11); +lean_dec(x_27); +lean_dec(x_9); +x_29 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set_uint8(x_29, sizeof(void*)*1, x_8); +x_30 = lean_array_push(x_2, x_29); +x_31 = lean_box(0); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_30); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_3); +return x_33; +} +} +} +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; uint8_t x_7; +x_6 = l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3(x_1, x_4, x_5); +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; uint8_t x_9; +x_8 = lean_ctor_get(x_6, 0); +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_8, 0); +lean_dec(x_10); +lean_ctor_set(x_8, 0, x_2); +return x_6; +} +else +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_2); +lean_ctor_set(x_12, 1, x_11); +lean_ctor_set(x_6, 0, x_12); +return x_6; +} +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_13 = lean_ctor_get(x_6, 0); +x_14 = lean_ctor_get(x_6, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_6); +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_16 = x_13; +} else { + lean_dec_ref(x_13); + x_16 = lean_box(0); +} +if (lean_is_scalar(x_16)) { + x_17 = lean_alloc_ctor(0, 2, 0); +} else { + x_17 = x_16; +} +lean_ctor_set(x_17, 0, x_2); +lean_ctor_set(x_17, 1, x_15); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_14); +return x_18; +} +} +} +static lean_object* _init_l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("\n", 1); +return x_1; +} +} +static lean_object* _init_l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout:\n", 8); +return x_1; +} +} +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_1); +lean_ctor_set(x_5, 1, x_3); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +return x_6; +} +else +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_2); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_16; +x_8 = lean_ctor_get(x_2, 0); +x_9 = lean_ctor_get(x_2, 1); +lean_inc(x_8); +x_16 = l_Lean_Json_parse(x_8); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +lean_dec(x_16); +x_17 = l_String_isEmpty(x_1); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_string_append(x_1, x_8); +lean_dec(x_8); +x_19 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_20 = lean_string_append(x_18, x_19); +lean_ctor_set_tag(x_2, 0); +lean_ctor_set(x_2, 1, x_3); +lean_ctor_set(x_2, 0, x_20); +x_10 = x_2; +x_11 = x_4; +goto block_15; +} +else +{ +uint8_t x_21; +x_21 = l_String_isEmpty(x_8); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_string_append(x_1, x_8); +lean_dec(x_8); +x_23 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_24 = lean_string_append(x_22, x_23); +lean_ctor_set_tag(x_2, 0); +lean_ctor_set(x_2, 1, x_3); +lean_ctor_set(x_2, 0, x_24); +x_10 = x_2; +x_11 = x_4; +goto block_15; +} +else +{ +lean_dec(x_8); +lean_ctor_set_tag(x_2, 0); +lean_ctor_set(x_2, 1, x_3); +lean_ctor_set(x_2, 0, x_1); +x_10 = x_2; +x_11 = x_4; +goto block_15; +} +} +} +else +{ +lean_object* x_25; lean_object* x_26; +x_25 = lean_ctor_get(x_16, 0); +lean_inc(x_25); +lean_dec(x_16); +x_26 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2(x_25); +if (lean_obj_tag(x_26) == 0) +{ +uint8_t x_27; +lean_dec(x_26); +x_27 = l_String_isEmpty(x_1); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_string_append(x_1, x_8); +lean_dec(x_8); +x_29 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_30 = lean_string_append(x_28, x_29); +lean_ctor_set_tag(x_2, 0); +lean_ctor_set(x_2, 1, x_3); +lean_ctor_set(x_2, 0, x_30); +x_10 = x_2; +x_11 = x_4; +goto block_15; +} +else +{ +uint8_t x_31; +x_31 = l_String_isEmpty(x_8); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_string_append(x_1, x_8); +lean_dec(x_8); +x_33 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_34 = lean_string_append(x_32, x_33); +lean_ctor_set_tag(x_2, 0); +lean_ctor_set(x_2, 1, x_3); +lean_ctor_set(x_2, 0, x_34); +x_10 = x_2; +x_11 = x_4; +goto block_15; +} +else +{ +lean_dec(x_8); +lean_ctor_set_tag(x_2, 0); +lean_ctor_set(x_2, 1, x_3); +lean_ctor_set(x_2, 0, x_1); +x_10 = x_2; +x_11 = x_4; +goto block_15; +} +} +} +else +{ +lean_object* x_35; uint8_t x_36; +lean_free_object(x_2); +lean_dec(x_8); +x_35 = lean_ctor_get(x_26, 0); +lean_inc(x_35); +lean_dec(x_26); +x_36 = l_String_isEmpty(x_1); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_37 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2; +x_38 = lean_string_append(x_37, x_1); +x_39 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_40 = lean_string_append(x_38, x_39); +x_41 = 1; +x_42 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set_uint8(x_42, sizeof(void*)*1, x_41); +x_43 = lean_array_push(x_3, x_42); +x_44 = lean_box(0); +x_45 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1(x_35, x_1, x_44, x_43, x_4); +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_10 = x_46; +x_11 = x_47; +goto block_15; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_48 = lean_box(0); +x_49 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1(x_35, x_1, x_48, x_3, x_4); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_49, 1); +lean_inc(x_51); +lean_dec(x_49); +x_10 = x_50; +x_11 = x_51; +goto block_15; +} +} +} +block_15: +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_1 = x_12; +x_2 = x_9; +x_3 = x_13; +x_4 = x_11; +goto _start; +} +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_60; +x_52 = lean_ctor_get(x_2, 0); +x_53 = lean_ctor_get(x_2, 1); +lean_inc(x_53); +lean_inc(x_52); +lean_dec(x_2); +lean_inc(x_52); +x_60 = l_Lean_Json_parse(x_52); +if (lean_obj_tag(x_60) == 0) +{ +uint8_t x_61; +lean_dec(x_60); +x_61 = l_String_isEmpty(x_1); +if (x_61 == 0) +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_62 = lean_string_append(x_1, x_52); +lean_dec(x_52); +x_63 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_64 = lean_string_append(x_62, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_3); +x_54 = x_65; +x_55 = x_4; +goto block_59; +} +else +{ +uint8_t x_66; +x_66 = l_String_isEmpty(x_52); +if (x_66 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_67 = lean_string_append(x_1, x_52); +lean_dec(x_52); +x_68 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_69 = lean_string_append(x_67, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_3); +x_54 = x_70; +x_55 = x_4; +goto block_59; +} +else +{ +lean_object* x_71; +lean_dec(x_52); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_1); +lean_ctor_set(x_71, 1, x_3); +x_54 = x_71; +x_55 = x_4; +goto block_59; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; +x_72 = lean_ctor_get(x_60, 0); +lean_inc(x_72); +lean_dec(x_60); +x_73 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2(x_72); +if (lean_obj_tag(x_73) == 0) +{ +uint8_t x_74; +lean_dec(x_73); +x_74 = l_String_isEmpty(x_1); +if (x_74 == 0) +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_75 = lean_string_append(x_1, x_52); +lean_dec(x_52); +x_76 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_77 = lean_string_append(x_75, x_76); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_3); +x_54 = x_78; +x_55 = x_4; +goto block_59; +} +else +{ +uint8_t x_79; +x_79 = l_String_isEmpty(x_52); +if (x_79 == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_80 = lean_string_append(x_1, x_52); +lean_dec(x_52); +x_81 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1; +x_82 = lean_string_append(x_80, x_81); +x_83 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_3); +x_54 = x_83; +x_55 = x_4; +goto block_59; +} +else +{ +lean_object* x_84; +lean_dec(x_52); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_1); +lean_ctor_set(x_84, 1, x_3); +x_54 = x_84; +x_55 = x_4; +goto block_59; +} +} +} +else +{ +lean_object* x_85; uint8_t x_86; +lean_dec(x_52); +x_85 = lean_ctor_get(x_73, 0); +lean_inc(x_85); +lean_dec(x_73); +x_86 = l_String_isEmpty(x_1); +if (x_86 == 0) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_87 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2; +x_88 = lean_string_append(x_87, x_1); +x_89 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_90 = lean_string_append(x_88, x_89); +x_91 = 1; +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_91); +x_93 = lean_array_push(x_3, x_92); +x_94 = lean_box(0); +x_95 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1(x_85, x_1, x_94, x_93, x_4); +x_96 = lean_ctor_get(x_95, 0); +lean_inc(x_96); +x_97 = lean_ctor_get(x_95, 1); +lean_inc(x_97); +lean_dec(x_95); +x_54 = x_96; +x_55 = x_97; +goto block_59; +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_98 = lean_box(0); +x_99 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1(x_85, x_1, x_98, x_3, x_4); +x_100 = lean_ctor_get(x_99, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_99, 1); +lean_inc(x_101); +lean_dec(x_99); +x_54 = x_100; +x_55 = x_101; +goto block_59; +} +} +} +block_59: +{ +lean_object* x_56; lean_object* x_57; +x_56 = lean_ctor_get(x_54, 0); +lean_inc(x_56); +x_57 = lean_ctor_get(x_54, 1); +lean_inc(x_57); +lean_dec(x_54); +x_1 = x_56; +x_2 = x_53; +x_3 = x_57; +x_4 = x_55; +goto _start; +} +} +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lean exited with code ", 22); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint32_t x_5; uint32_t x_6; uint8_t x_7; uint8_t x_8; +x_5 = lean_ctor_get_uint32(x_1, sizeof(void*)*2); +x_6 = 0; +x_7 = lean_uint32_dec_eq(x_5, x_6); +x_8 = l_instDecidableNot___rarg(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_box(0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_3); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_4); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_12 = lean_uint32_to_nat(x_5); +x_13 = l___private_Init_Data_Repr_0__Nat_reprFast(x_12); +x_14 = l_Lake_compileLeanModule___lambda__1___closed__1; +x_15 = lean_string_append(x_14, x_13); +lean_dec(x_13); +x_16 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_17 = lean_string_append(x_15, x_16); +x_18 = 3; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = lean_array_get_size(x_3); +x_21 = lean_array_push(x_3, x_19); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_4); +return x_23; +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stderr:\n", 8); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; uint8_t x_6; +x_5 = lean_ctor_get(x_1, 1); +x_6 = l_String_isEmpty(x_5); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_7 = l_Lake_compileLeanModule___lambda__2___closed__1; +x_8 = lean_string_append(x_7, x_5); +x_9 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_10 = lean_string_append(x_8, x_9); +x_11 = 1; +x_12 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set_uint8(x_12, sizeof(void*)*1, x_11); +x_13 = lean_array_push(x_3, x_12); +x_14 = lean_box(0); +x_15 = l_Lake_compileLeanModule___lambda__1(x_1, x_14, x_13, x_4); +return x_15; +} +else +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_box(0); +x_17 = l_Lake_compileLeanModule___lambda__1(x_1, x_16, x_3, x_4); +return x_17; +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("failed to execute '", 19); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__3___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("': ", 3); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_51; +x_51 = l_IO_Process_output(x_1, x_5); +if (lean_obj_tag(x_51) == 0) +{ +uint8_t x_52; +x_52 = !lean_is_exclusive(x_51); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_51, 0); +x_54 = lean_ctor_get(x_51, 1); +x_55 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_51, 1, x_4); +lean_ctor_set(x_51, 0, x_55); +x_6 = x_51; +x_7 = x_54; +goto block_50; +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_51, 0); +x_57 = lean_ctor_get(x_51, 1); +lean_inc(x_57); +lean_inc(x_56); +lean_dec(x_51); +x_58 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_58, 0, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_4); +x_6 = x_59; +x_7 = x_57; +goto block_50; +} +} +else +{ +uint8_t x_60; +x_60 = !lean_is_exclusive(x_51); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_61 = lean_ctor_get(x_51, 0); +x_62 = lean_ctor_get(x_51, 1); +x_63 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set_tag(x_51, 0); +lean_ctor_set(x_51, 1, x_4); +lean_ctor_set(x_51, 0, x_63); +x_6 = x_51; +x_7 = x_62; +goto block_50; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_64 = lean_ctor_get(x_51, 0); +x_65 = lean_ctor_get(x_51, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_51); +x_66 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_66, 0, x_64); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_4); +x_6 = x_67; +x_7 = x_65; +goto block_50; +} +} +block_50: +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_6); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_10 = lean_ctor_get(x_6, 1); +x_11 = lean_ctor_get(x_6, 0); +lean_dec(x_11); +x_12 = lean_ctor_get(x_8, 0); +lean_inc(x_12); +lean_dec(x_8); +x_13 = l_Lake_compileLeanModule___lambda__3___closed__1; +x_14 = lean_string_append(x_13, x_2); +x_15 = l_Lake_compileLeanModule___lambda__3___closed__2; +x_16 = lean_string_append(x_14, x_15); +x_17 = lean_io_error_to_string(x_12); +x_18 = lean_string_append(x_16, x_17); +lean_dec(x_17); +x_19 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_20 = lean_string_append(x_18, x_19); +x_21 = 3; +x_22 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set_uint8(x_22, sizeof(void*)*1, x_21); +x_23 = lean_array_get_size(x_10); +x_24 = lean_array_push(x_10, x_22); +lean_ctor_set_tag(x_6, 1); +lean_ctor_set(x_6, 1, x_24); +lean_ctor_set(x_6, 0, x_23); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_6); +lean_ctor_set(x_25, 1, x_7); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_26 = lean_ctor_get(x_6, 1); +lean_inc(x_26); +lean_dec(x_6); +x_27 = lean_ctor_get(x_8, 0); +lean_inc(x_27); +lean_dec(x_8); +x_28 = l_Lake_compileLeanModule___lambda__3___closed__1; +x_29 = lean_string_append(x_28, x_2); +x_30 = l_Lake_compileLeanModule___lambda__3___closed__2; +x_31 = lean_string_append(x_29, x_30); +x_32 = lean_io_error_to_string(x_27); +x_33 = lean_string_append(x_31, x_32); +lean_dec(x_32); +x_34 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_35 = lean_string_append(x_33, x_34); +x_36 = 3; +x_37 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set_uint8(x_37, sizeof(void*)*1, x_36); +x_38 = lean_array_get_size(x_26); +x_39 = lean_array_push(x_26, x_37); +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_7); +return x_41; +} +} +else +{ +uint8_t x_42; +x_42 = !lean_is_exclusive(x_6); +if (x_42 == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_6, 0); +lean_dec(x_43); +x_44 = lean_ctor_get(x_8, 0); +lean_inc(x_44); +lean_dec(x_8); +lean_ctor_set(x_6, 0, x_44); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_6); +lean_ctor_set(x_45, 1, x_7); +return x_45; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_46 = lean_ctor_get(x_6, 1); +lean_inc(x_46); +lean_dec(x_6); +x_47 = lean_ctor_get(x_8, 0); +lean_inc(x_47); +lean_dec(x_8); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_46); +x_49 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_7); +return x_49; +} +} +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__4___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("--json", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__4___closed__2() { +_start: +{ +uint8_t x_1; lean_object* x_2; +x_1 = 1; +x_2 = lean_alloc_ctor(0, 0, 3); +lean_ctor_set_uint8(x_2, 0, x_1); +lean_ctor_set_uint8(x_2, 1, x_1); +lean_ctor_set_uint8(x_2, 2, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__4___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("LEAN_PATH", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__4___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(2u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; size_t x_10; size_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_9 = lean_array_get_size(x_1); +x_10 = lean_usize_of_nat(x_9); +lean_dec(x_9); +x_11 = 0; +x_12 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1(x_1, x_10, x_11, x_5, x_7, x_8); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_15 = x_12; +} else { + lean_dec_ref(x_12); + x_15 = lean_box(0); +} +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_103; lean_object* x_104; uint8_t x_105; +x_17 = lean_ctor_get(x_13, 0); +x_18 = lean_ctor_get(x_13, 1); +x_19 = l_Lake_compileLeanModule___lambda__4___closed__1; +x_20 = lean_array_push(x_17, x_19); +x_21 = lean_array_get_size(x_18); +x_103 = l_Lake_sharedLibPathEnvVar; +x_104 = l_Lake_getSearchPath(x_103, x_14); +x_105 = !lean_is_exclusive(x_104); +if (x_105 == 0) +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; uint8_t x_119; lean_object* x_120; lean_object* x_121; uint8_t x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +x_106 = lean_ctor_get(x_104, 0); +x_107 = lean_ctor_get(x_104, 1); +x_108 = lean_box(0); +x_109 = l_System_SearchPath_toString(x_2); +x_110 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_110, 0, x_109); +x_111 = l_Lake_compileLeanModule___lambda__4___closed__3; +lean_ctor_set(x_104, 1, x_110); +lean_ctor_set(x_104, 0, x_111); +x_112 = l_List_appendTR___rarg(x_106, x_3); +x_113 = l_System_SearchPath_toString(x_112); +x_114 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_13, 1, x_114); +lean_ctor_set(x_13, 0, x_103); +x_115 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_116 = lean_array_push(x_115, x_104); +x_117 = lean_array_push(x_116, x_13); +x_118 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_119 = 0; +lean_inc(x_4); +x_120 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_120, 0, x_118); +lean_ctor_set(x_120, 1, x_4); +lean_ctor_set(x_120, 2, x_20); +lean_ctor_set(x_120, 3, x_108); +lean_ctor_set(x_120, 4, x_117); +lean_ctor_set_uint8(x_120, sizeof(void*)*5, x_119); +lean_inc(x_120); +x_121 = l_Lake_mkCmdLog(x_120); +x_122 = 0; +x_123 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_123, 0, x_121); +lean_ctor_set_uint8(x_123, sizeof(void*)*1, x_122); +x_124 = lean_array_push(x_18, x_123); +x_125 = lean_box(0); +x_126 = l_Lake_compileLeanModule___lambda__3(x_120, x_4, x_125, x_124, x_107); +lean_dec(x_4); +x_127 = lean_ctor_get(x_126, 0); +lean_inc(x_127); +if (lean_obj_tag(x_127) == 0) +{ +lean_object* x_128; +x_128 = lean_ctor_get(x_126, 1); +lean_inc(x_128); +lean_dec(x_126); +x_22 = x_127; +x_23 = x_128; +goto block_102; +} +else +{ +lean_object* x_129; uint8_t x_130; +x_129 = lean_ctor_get(x_126, 1); +lean_inc(x_129); +lean_dec(x_126); +x_130 = !lean_is_exclusive(x_127); +if (x_130 == 0) +{ +lean_object* x_131; +x_131 = lean_ctor_get(x_127, 0); +lean_dec(x_131); +lean_inc(x_21); +lean_ctor_set(x_127, 0, x_21); +x_22 = x_127; +x_23 = x_129; +goto block_102; +} +else +{ +lean_object* x_132; lean_object* x_133; +x_132 = lean_ctor_get(x_127, 1); +lean_inc(x_132); +lean_dec(x_127); +lean_inc(x_21); +x_133 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_133, 0, x_21); +lean_ctor_set(x_133, 1, x_132); +x_22 = x_133; +x_23 = x_129; +goto block_102; +} +} +} +else +{ +lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; lean_object* x_149; lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +x_134 = lean_ctor_get(x_104, 0); +x_135 = lean_ctor_get(x_104, 1); +lean_inc(x_135); +lean_inc(x_134); +lean_dec(x_104); +x_136 = lean_box(0); +x_137 = l_System_SearchPath_toString(x_2); +x_138 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_138, 0, x_137); +x_139 = l_Lake_compileLeanModule___lambda__4___closed__3; +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_139); +lean_ctor_set(x_140, 1, x_138); +x_141 = l_List_appendTR___rarg(x_134, x_3); +x_142 = l_System_SearchPath_toString(x_141); +x_143 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_143, 0, x_142); +lean_ctor_set(x_13, 1, x_143); +lean_ctor_set(x_13, 0, x_103); +x_144 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_145 = lean_array_push(x_144, x_140); +x_146 = lean_array_push(x_145, x_13); +x_147 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_148 = 0; +lean_inc(x_4); +x_149 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_149, 0, x_147); +lean_ctor_set(x_149, 1, x_4); +lean_ctor_set(x_149, 2, x_20); +lean_ctor_set(x_149, 3, x_136); +lean_ctor_set(x_149, 4, x_146); +lean_ctor_set_uint8(x_149, sizeof(void*)*5, x_148); +lean_inc(x_149); +x_150 = l_Lake_mkCmdLog(x_149); +x_151 = 0; +x_152 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set_uint8(x_152, sizeof(void*)*1, x_151); +x_153 = lean_array_push(x_18, x_152); +x_154 = lean_box(0); +x_155 = l_Lake_compileLeanModule___lambda__3(x_149, x_4, x_154, x_153, x_135); +lean_dec(x_4); +x_156 = lean_ctor_get(x_155, 0); +lean_inc(x_156); +if (lean_obj_tag(x_156) == 0) +{ +lean_object* x_157; +x_157 = lean_ctor_get(x_155, 1); +lean_inc(x_157); +lean_dec(x_155); +x_22 = x_156; +x_23 = x_157; +goto block_102; +} +else +{ +lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; +x_158 = lean_ctor_get(x_155, 1); +lean_inc(x_158); +lean_dec(x_155); +x_159 = lean_ctor_get(x_156, 1); +lean_inc(x_159); +if (lean_is_exclusive(x_156)) { + lean_ctor_release(x_156, 0); + lean_ctor_release(x_156, 1); + x_160 = x_156; +} else { + lean_dec_ref(x_156); + x_160 = lean_box(0); +} +lean_inc(x_21); +if (lean_is_scalar(x_160)) { + x_161 = lean_alloc_ctor(1, 2, 0); +} else { + x_161 = x_160; +} +lean_ctor_set(x_161, 0, x_21); +lean_ctor_set(x_161, 1, x_159); +x_22 = x_161; +x_23 = x_158; +goto block_102; +} +} +block_102: +{ +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; +lean_dec(x_15); +x_24 = lean_ctor_get(x_22, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +lean_dec(x_22); +x_26 = lean_ctor_get(x_24, 0); +lean_inc(x_26); +x_27 = l_String_isEmpty(x_26); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; +x_28 = l_String_split___at_Lean_stringToMessageData___spec__1(x_26); +lean_dec(x_26); +x_29 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_30 = l_List_foldlM___at_Lake_compileLeanModule___spec__4(x_29, x_28, x_25, x_23); +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_ctor_get(x_31, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_31, 1); +lean_inc(x_34); +lean_dec(x_31); +x_35 = l_String_isEmpty(x_33); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_36 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2; +x_37 = lean_string_append(x_36, x_33); +lean_dec(x_33); +x_38 = lean_string_append(x_37, x_29); +x_39 = 1; +x_40 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set_uint8(x_40, sizeof(void*)*1, x_39); +x_41 = lean_array_push(x_34, x_40); +x_42 = lean_box(0); +x_43 = l_Lake_compileLeanModule___lambda__2(x_24, x_42, x_41, x_32); +lean_dec(x_24); +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +if (lean_obj_tag(x_44) == 0) +{ +uint8_t x_45; +lean_dec(x_21); +x_45 = !lean_is_exclusive(x_43); +if (x_45 == 0) +{ +lean_object* x_46; +x_46 = lean_ctor_get(x_43, 0); +lean_dec(x_46); +return x_43; +} +else +{ +lean_object* x_47; lean_object* x_48; +x_47 = lean_ctor_get(x_43, 1); +lean_inc(x_47); +lean_dec(x_43); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_44); +lean_ctor_set(x_48, 1, x_47); +return x_48; +} +} +else +{ +uint8_t x_49; +x_49 = !lean_is_exclusive(x_43); +if (x_49 == 0) +{ +lean_object* x_50; uint8_t x_51; +x_50 = lean_ctor_get(x_43, 0); +lean_dec(x_50); +x_51 = !lean_is_exclusive(x_44); +if (x_51 == 0) +{ +lean_object* x_52; +x_52 = lean_ctor_get(x_44, 0); +lean_dec(x_52); +lean_ctor_set(x_44, 0, x_21); +return x_43; +} +else +{ +lean_object* x_53; lean_object* x_54; +x_53 = lean_ctor_get(x_44, 1); +lean_inc(x_53); +lean_dec(x_44); +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_21); +lean_ctor_set(x_54, 1, x_53); +lean_ctor_set(x_43, 0, x_54); +return x_43; +} +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_43, 1); +lean_inc(x_55); +lean_dec(x_43); +x_56 = lean_ctor_get(x_44, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_57 = x_44; +} else { + lean_dec_ref(x_44); + x_57 = lean_box(0); +} +if (lean_is_scalar(x_57)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_57; +} +lean_ctor_set(x_58, 0, x_21); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_55); +return x_59; +} +} +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; +lean_dec(x_33); +x_60 = lean_box(0); +x_61 = l_Lake_compileLeanModule___lambda__2(x_24, x_60, x_34, x_32); +lean_dec(x_24); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +if (lean_obj_tag(x_62) == 0) +{ +uint8_t x_63; +lean_dec(x_21); +x_63 = !lean_is_exclusive(x_61); +if (x_63 == 0) +{ +lean_object* x_64; +x_64 = lean_ctor_get(x_61, 0); +lean_dec(x_64); +return x_61; +} +else +{ +lean_object* x_65; lean_object* x_66; +x_65 = lean_ctor_get(x_61, 1); +lean_inc(x_65); +lean_dec(x_61); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_62); +lean_ctor_set(x_66, 1, x_65); +return x_66; +} +} +else +{ +uint8_t x_67; +x_67 = !lean_is_exclusive(x_61); +if (x_67 == 0) +{ +lean_object* x_68; uint8_t x_69; +x_68 = lean_ctor_get(x_61, 0); +lean_dec(x_68); +x_69 = !lean_is_exclusive(x_62); +if (x_69 == 0) +{ +lean_object* x_70; +x_70 = lean_ctor_get(x_62, 0); +lean_dec(x_70); +lean_ctor_set(x_62, 0, x_21); +return x_61; +} +else +{ +lean_object* x_71; lean_object* x_72; +x_71 = lean_ctor_get(x_62, 1); +lean_inc(x_71); +lean_dec(x_62); +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_21); +lean_ctor_set(x_72, 1, x_71); +lean_ctor_set(x_61, 0, x_72); +return x_61; +} +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_73 = lean_ctor_get(x_61, 1); +lean_inc(x_73); +lean_dec(x_61); +x_74 = lean_ctor_get(x_62, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_62)) { + lean_ctor_release(x_62, 0); + lean_ctor_release(x_62, 1); + x_75 = x_62; +} else { + lean_dec_ref(x_62); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_21); +lean_ctor_set(x_76, 1, x_74); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_73); +return x_77; +} +} +} +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; +lean_dec(x_26); +x_78 = lean_box(0); +x_79 = l_Lake_compileLeanModule___lambda__2(x_24, x_78, x_25, x_23); +lean_dec(x_24); +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +if (lean_obj_tag(x_80) == 0) +{ +uint8_t x_81; +lean_dec(x_21); +x_81 = !lean_is_exclusive(x_79); +if (x_81 == 0) +{ +lean_object* x_82; +x_82 = lean_ctor_get(x_79, 0); +lean_dec(x_82); +return x_79; +} +else +{ +lean_object* x_83; lean_object* x_84; +x_83 = lean_ctor_get(x_79, 1); +lean_inc(x_83); +lean_dec(x_79); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_80); +lean_ctor_set(x_84, 1, x_83); +return x_84; +} +} +else +{ +uint8_t x_85; +x_85 = !lean_is_exclusive(x_79); +if (x_85 == 0) +{ +lean_object* x_86; uint8_t x_87; +x_86 = lean_ctor_get(x_79, 0); +lean_dec(x_86); +x_87 = !lean_is_exclusive(x_80); +if (x_87 == 0) +{ +lean_object* x_88; +x_88 = lean_ctor_get(x_80, 0); +lean_dec(x_88); +lean_ctor_set(x_80, 0, x_21); +return x_79; +} +else +{ +lean_object* x_89; lean_object* x_90; +x_89 = lean_ctor_get(x_80, 1); +lean_inc(x_89); +lean_dec(x_80); +x_90 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_90, 0, x_21); +lean_ctor_set(x_90, 1, x_89); +lean_ctor_set(x_79, 0, x_90); +return x_79; +} +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_91 = lean_ctor_get(x_79, 1); +lean_inc(x_91); +lean_dec(x_79); +x_92 = lean_ctor_get(x_80, 1); +lean_inc(x_92); +if (lean_is_exclusive(x_80)) { + lean_ctor_release(x_80, 0); + lean_ctor_release(x_80, 1); + x_93 = x_80; +} else { + lean_dec_ref(x_80); + x_93 = lean_box(0); +} +if (lean_is_scalar(x_93)) { + x_94 = lean_alloc_ctor(1, 2, 0); +} else { + x_94 = x_93; +} +lean_ctor_set(x_94, 0, x_21); +lean_ctor_set(x_94, 1, x_92); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_91); +return x_95; +} +} +} +} +else +{ +uint8_t x_96; +x_96 = !lean_is_exclusive(x_22); +if (x_96 == 0) +{ +lean_object* x_97; lean_object* x_98; +x_97 = lean_ctor_get(x_22, 0); +lean_dec(x_97); +lean_ctor_set(x_22, 0, x_21); +if (lean_is_scalar(x_15)) { + x_98 = lean_alloc_ctor(0, 2, 0); +} else { + x_98 = x_15; +} +lean_ctor_set(x_98, 0, x_22); +lean_ctor_set(x_98, 1, x_23); +return x_98; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_22, 1); +lean_inc(x_99); +lean_dec(x_22); +x_100 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_100, 0, x_21); +lean_ctor_set(x_100, 1, x_99); +if (lean_is_scalar(x_15)) { + x_101 = lean_alloc_ctor(0, 2, 0); +} else { + x_101 = x_15; +} +lean_ctor_set(x_101, 0, x_100); +lean_ctor_set(x_101, 1, x_23); +return x_101; +} +} +} +} +else +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; +x_162 = lean_ctor_get(x_13, 0); +x_163 = lean_ctor_get(x_13, 1); +lean_inc(x_163); +lean_inc(x_162); +lean_dec(x_13); +x_164 = l_Lake_compileLeanModule___lambda__4___closed__1; +x_165 = lean_array_push(x_162, x_164); +x_166 = lean_array_get_size(x_163); +x_228 = l_Lake_sharedLibPathEnvVar; +x_229 = l_Lake_getSearchPath(x_228, x_14); +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +x_231 = lean_ctor_get(x_229, 1); +lean_inc(x_231); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_232 = x_229; +} else { + lean_dec_ref(x_229); + x_232 = lean_box(0); +} +x_233 = lean_box(0); +x_234 = l_System_SearchPath_toString(x_2); +x_235 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_235, 0, x_234); +x_236 = l_Lake_compileLeanModule___lambda__4___closed__3; +if (lean_is_scalar(x_232)) { + x_237 = lean_alloc_ctor(0, 2, 0); +} else { + x_237 = x_232; +} +lean_ctor_set(x_237, 0, x_236); +lean_ctor_set(x_237, 1, x_235); +x_238 = l_List_appendTR___rarg(x_230, x_3); +x_239 = l_System_SearchPath_toString(x_238); +x_240 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_240, 0, x_239); +x_241 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_241, 0, x_228); +lean_ctor_set(x_241, 1, x_240); +x_242 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_243 = lean_array_push(x_242, x_237); +x_244 = lean_array_push(x_243, x_241); +x_245 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_246 = 0; +lean_inc(x_4); +x_247 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_247, 0, x_245); +lean_ctor_set(x_247, 1, x_4); +lean_ctor_set(x_247, 2, x_165); +lean_ctor_set(x_247, 3, x_233); +lean_ctor_set(x_247, 4, x_244); +lean_ctor_set_uint8(x_247, sizeof(void*)*5, x_246); +lean_inc(x_247); +x_248 = l_Lake_mkCmdLog(x_247); +x_249 = 0; +x_250 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_250, 0, x_248); +lean_ctor_set_uint8(x_250, sizeof(void*)*1, x_249); +x_251 = lean_array_push(x_163, x_250); +x_252 = lean_box(0); +x_253 = l_Lake_compileLeanModule___lambda__3(x_247, x_4, x_252, x_251, x_231); +lean_dec(x_4); +x_254 = lean_ctor_get(x_253, 0); +lean_inc(x_254); +if (lean_obj_tag(x_254) == 0) +{ +lean_object* x_255; +x_255 = lean_ctor_get(x_253, 1); +lean_inc(x_255); +lean_dec(x_253); +x_167 = x_254; +x_168 = x_255; +goto block_227; +} +else +{ +lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; +x_256 = lean_ctor_get(x_253, 1); +lean_inc(x_256); +lean_dec(x_253); +x_257 = lean_ctor_get(x_254, 1); +lean_inc(x_257); +if (lean_is_exclusive(x_254)) { + lean_ctor_release(x_254, 0); + lean_ctor_release(x_254, 1); + x_258 = x_254; +} else { + lean_dec_ref(x_254); + x_258 = lean_box(0); +} +lean_inc(x_166); +if (lean_is_scalar(x_258)) { + x_259 = lean_alloc_ctor(1, 2, 0); +} else { + x_259 = x_258; +} +lean_ctor_set(x_259, 0, x_166); +lean_ctor_set(x_259, 1, x_257); +x_167 = x_259; +x_168 = x_256; +goto block_227; +} +block_227: +{ +if (lean_obj_tag(x_167) == 0) +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; +lean_dec(x_15); +x_169 = lean_ctor_get(x_167, 0); +lean_inc(x_169); +x_170 = lean_ctor_get(x_167, 1); +lean_inc(x_170); +lean_dec(x_167); +x_171 = lean_ctor_get(x_169, 0); +lean_inc(x_171); +x_172 = l_String_isEmpty(x_171); +if (x_172 == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; uint8_t x_180; +x_173 = l_String_split___at_Lean_stringToMessageData___spec__1(x_171); +lean_dec(x_171); +x_174 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_175 = l_List_foldlM___at_Lake_compileLeanModule___spec__4(x_174, x_173, x_170, x_168); +x_176 = lean_ctor_get(x_175, 0); +lean_inc(x_176); +x_177 = lean_ctor_get(x_175, 1); +lean_inc(x_177); +lean_dec(x_175); +x_178 = lean_ctor_get(x_176, 0); +lean_inc(x_178); +x_179 = lean_ctor_get(x_176, 1); +lean_inc(x_179); +lean_dec(x_176); +x_180 = l_String_isEmpty(x_178); +if (x_180 == 0) +{ +lean_object* x_181; lean_object* x_182; lean_object* x_183; uint8_t x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; +x_181 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2; +x_182 = lean_string_append(x_181, x_178); +lean_dec(x_178); +x_183 = lean_string_append(x_182, x_174); +x_184 = 1; +x_185 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_185, 0, x_183); +lean_ctor_set_uint8(x_185, sizeof(void*)*1, x_184); +x_186 = lean_array_push(x_179, x_185); +x_187 = lean_box(0); +x_188 = l_Lake_compileLeanModule___lambda__2(x_169, x_187, x_186, x_177); +lean_dec(x_169); +x_189 = lean_ctor_get(x_188, 0); +lean_inc(x_189); +if (lean_obj_tag(x_189) == 0) +{ +lean_object* x_190; lean_object* x_191; lean_object* x_192; +lean_dec(x_166); +x_190 = lean_ctor_get(x_188, 1); +lean_inc(x_190); +if (lean_is_exclusive(x_188)) { + lean_ctor_release(x_188, 0); + lean_ctor_release(x_188, 1); + x_191 = x_188; +} else { + lean_dec_ref(x_188); + x_191 = lean_box(0); +} +if (lean_is_scalar(x_191)) { + x_192 = lean_alloc_ctor(0, 2, 0); +} else { + x_192 = x_191; +} +lean_ctor_set(x_192, 0, x_189); +lean_ctor_set(x_192, 1, x_190); +return x_192; +} +else +{ +lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; +x_193 = lean_ctor_get(x_188, 1); +lean_inc(x_193); +if (lean_is_exclusive(x_188)) { + lean_ctor_release(x_188, 0); + lean_ctor_release(x_188, 1); + x_194 = x_188; +} else { + lean_dec_ref(x_188); + x_194 = lean_box(0); +} +x_195 = lean_ctor_get(x_189, 1); +lean_inc(x_195); +if (lean_is_exclusive(x_189)) { + lean_ctor_release(x_189, 0); + lean_ctor_release(x_189, 1); + x_196 = x_189; +} else { + lean_dec_ref(x_189); + x_196 = lean_box(0); +} +if (lean_is_scalar(x_196)) { + x_197 = lean_alloc_ctor(1, 2, 0); +} else { + x_197 = x_196; +} +lean_ctor_set(x_197, 0, x_166); +lean_ctor_set(x_197, 1, x_195); +if (lean_is_scalar(x_194)) { + x_198 = lean_alloc_ctor(0, 2, 0); +} else { + x_198 = x_194; +} +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_193); +return x_198; +} +} +else +{ +lean_object* x_199; lean_object* x_200; lean_object* x_201; +lean_dec(x_178); +x_199 = lean_box(0); +x_200 = l_Lake_compileLeanModule___lambda__2(x_169, x_199, x_179, x_177); +lean_dec(x_169); +x_201 = lean_ctor_get(x_200, 0); +lean_inc(x_201); +if (lean_obj_tag(x_201) == 0) +{ +lean_object* x_202; lean_object* x_203; lean_object* x_204; +lean_dec(x_166); +x_202 = lean_ctor_get(x_200, 1); +lean_inc(x_202); +if (lean_is_exclusive(x_200)) { + lean_ctor_release(x_200, 0); + lean_ctor_release(x_200, 1); + x_203 = x_200; +} else { + lean_dec_ref(x_200); + x_203 = lean_box(0); +} +if (lean_is_scalar(x_203)) { + x_204 = lean_alloc_ctor(0, 2, 0); +} else { + x_204 = x_203; +} +lean_ctor_set(x_204, 0, x_201); +lean_ctor_set(x_204, 1, x_202); +return x_204; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +x_205 = lean_ctor_get(x_200, 1); +lean_inc(x_205); +if (lean_is_exclusive(x_200)) { + lean_ctor_release(x_200, 0); + lean_ctor_release(x_200, 1); + x_206 = x_200; +} else { + lean_dec_ref(x_200); + x_206 = lean_box(0); +} +x_207 = lean_ctor_get(x_201, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_201)) { + lean_ctor_release(x_201, 0); + lean_ctor_release(x_201, 1); + x_208 = x_201; +} else { + lean_dec_ref(x_201); + x_208 = lean_box(0); +} +if (lean_is_scalar(x_208)) { + x_209 = lean_alloc_ctor(1, 2, 0); +} else { + x_209 = x_208; +} +lean_ctor_set(x_209, 0, x_166); +lean_ctor_set(x_209, 1, x_207); +if (lean_is_scalar(x_206)) { + x_210 = lean_alloc_ctor(0, 2, 0); +} else { + x_210 = x_206; +} +lean_ctor_set(x_210, 0, x_209); +lean_ctor_set(x_210, 1, x_205); +return x_210; +} +} +} +else +{ +lean_object* x_211; lean_object* x_212; lean_object* x_213; +lean_dec(x_171); +x_211 = lean_box(0); +x_212 = l_Lake_compileLeanModule___lambda__2(x_169, x_211, x_170, x_168); +lean_dec(x_169); +x_213 = lean_ctor_get(x_212, 0); +lean_inc(x_213); +if (lean_obj_tag(x_213) == 0) +{ +lean_object* x_214; lean_object* x_215; lean_object* x_216; +lean_dec(x_166); +x_214 = lean_ctor_get(x_212, 1); +lean_inc(x_214); +if (lean_is_exclusive(x_212)) { + lean_ctor_release(x_212, 0); + lean_ctor_release(x_212, 1); + x_215 = x_212; +} else { + lean_dec_ref(x_212); + x_215 = lean_box(0); +} +if (lean_is_scalar(x_215)) { + x_216 = lean_alloc_ctor(0, 2, 0); +} else { + x_216 = x_215; +} +lean_ctor_set(x_216, 0, x_213); +lean_ctor_set(x_216, 1, x_214); +return x_216; +} +else +{ +lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_217 = lean_ctor_get(x_212, 1); +lean_inc(x_217); +if (lean_is_exclusive(x_212)) { + lean_ctor_release(x_212, 0); + lean_ctor_release(x_212, 1); + x_218 = x_212; +} else { + lean_dec_ref(x_212); + x_218 = lean_box(0); +} +x_219 = lean_ctor_get(x_213, 1); +lean_inc(x_219); +if (lean_is_exclusive(x_213)) { + lean_ctor_release(x_213, 0); + lean_ctor_release(x_213, 1); + x_220 = x_213; +} else { + lean_dec_ref(x_213); + x_220 = lean_box(0); +} +if (lean_is_scalar(x_220)) { + x_221 = lean_alloc_ctor(1, 2, 0); +} else { + x_221 = x_220; +} +lean_ctor_set(x_221, 0, x_166); +lean_ctor_set(x_221, 1, x_219); +if (lean_is_scalar(x_218)) { + x_222 = lean_alloc_ctor(0, 2, 0); +} else { + x_222 = x_218; +} +lean_ctor_set(x_222, 0, x_221); +lean_ctor_set(x_222, 1, x_217); +return x_222; +} +} +} +else +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_223 = lean_ctor_get(x_167, 1); +lean_inc(x_223); +if (lean_is_exclusive(x_167)) { + lean_ctor_release(x_167, 0); + lean_ctor_release(x_167, 1); + x_224 = x_167; +} else { + lean_dec_ref(x_167); + x_224 = lean_box(0); +} +if (lean_is_scalar(x_224)) { + x_225 = lean_alloc_ctor(1, 2, 0); +} else { + x_225 = x_224; +} +lean_ctor_set(x_225, 0, x_166); +lean_ctor_set(x_225, 1, x_223); +if (lean_is_scalar(x_15)) { + x_226 = lean_alloc_ctor(0, 2, 0); +} else { + x_226 = x_15; +} +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_168); +return x_226; +} +} +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__5___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-b", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__5___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_2 = l_Lake_compileLeanModule___lambda__5___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_box(0); +x_11 = l_Lake_compileLeanModule___lambda__4(x_1, x_2, x_3, x_4, x_6, x_10, x_8, x_9); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_5, 0); +lean_inc(x_12); +lean_dec(x_5); +lean_inc(x_12); +x_13 = l_Lake_createParentDirs(x_12, x_9); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_14 = lean_ctor_get(x_13, 1); +lean_inc(x_14); +lean_dec(x_13); +x_15 = l_Lake_compileLeanModule___lambda__5___closed__2; +x_16 = lean_array_push(x_15, x_12); +x_17 = l_Array_append___rarg(x_6, x_16); +lean_dec(x_16); +x_18 = lean_box(0); +x_19 = l_Lake_compileLeanModule___lambda__4(x_1, x_2, x_3, x_4, x_17, x_18, x_8, x_14); +return x_19; +} +else +{ +uint8_t x_20; +lean_dec(x_12); +lean_dec(x_6); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_20 = !lean_is_exclusive(x_13); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_21 = lean_ctor_get(x_13, 0); +x_22 = lean_io_error_to_string(x_21); +x_23 = 3; +x_24 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set_uint8(x_24, sizeof(void*)*1, x_23); +x_25 = lean_array_get_size(x_8); +x_26 = lean_array_push(x_8, x_24); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +lean_ctor_set_tag(x_13, 0); +lean_ctor_set(x_13, 0, x_27); +return x_13; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_28 = lean_ctor_get(x_13, 0); +x_29 = lean_ctor_get(x_13, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_13); +x_30 = lean_io_error_to_string(x_28); +x_31 = 3; +x_32 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set_uint8(x_32, sizeof(void*)*1, x_31); +x_33 = lean_array_get_size(x_8); +x_34 = lean_array_push(x_8, x_32); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_29); +return x_36; +} +} +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__6___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-c", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__6___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_2 = l_Lake_compileLeanModule___lambda__6___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_box(0); +x_12 = l_Lake_compileLeanModule___lambda__5(x_1, x_2, x_3, x_4, x_5, x_7, x_11, x_9, x_10); +return x_12; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_6, 0); +lean_inc(x_13); +lean_dec(x_6); +lean_inc(x_13); +x_14 = l_Lake_createParentDirs(x_13, x_10); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_14, 1); +lean_inc(x_15); +lean_dec(x_14); +x_16 = l_Lake_compileLeanModule___lambda__6___closed__2; +x_17 = lean_array_push(x_16, x_13); +x_18 = l_Array_append___rarg(x_7, x_17); +lean_dec(x_17); +x_19 = lean_box(0); +x_20 = l_Lake_compileLeanModule___lambda__5(x_1, x_2, x_3, x_4, x_5, x_18, x_19, x_9, x_15); +return x_20; +} +else +{ +uint8_t x_21; +lean_dec(x_13); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_21 = !lean_is_exclusive(x_14); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_22 = lean_ctor_get(x_14, 0); +x_23 = lean_io_error_to_string(x_22); +x_24 = 3; +x_25 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set_uint8(x_25, sizeof(void*)*1, x_24); +x_26 = lean_array_get_size(x_9); +x_27 = lean_array_push(x_9, x_25); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +lean_ctor_set_tag(x_14, 0); +lean_ctor_set(x_14, 0, x_28); +return x_14; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_29 = lean_ctor_get(x_14, 0); +x_30 = lean_ctor_get(x_14, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_14); +x_31 = lean_io_error_to_string(x_29); +x_32 = 3; +x_33 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set_uint8(x_33, sizeof(void*)*1, x_32); +x_34 = lean_array_get_size(x_9); +x_35 = lean_array_push(x_9, x_33); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_30); +return x_37; +} +} +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__7___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-i", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___lambda__7___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_2 = l_Lake_compileLeanModule___lambda__7___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__7(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_box(0); +x_13 = l_Lake_compileLeanModule___lambda__6(x_1, x_2, x_3, x_4, x_5, x_6, x_8, x_12, x_10, x_11); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; +x_14 = lean_ctor_get(x_7, 0); +lean_inc(x_14); +lean_dec(x_7); +lean_inc(x_14); +x_15 = l_Lake_createParentDirs(x_14, x_11); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_15, 1); +lean_inc(x_16); +lean_dec(x_15); +x_17 = l_Lake_compileLeanModule___lambda__7___closed__2; +x_18 = lean_array_push(x_17, x_14); +x_19 = l_Array_append___rarg(x_8, x_18); +lean_dec(x_18); +x_20 = lean_box(0); +x_21 = l_Lake_compileLeanModule___lambda__6(x_1, x_2, x_3, x_4, x_5, x_6, x_19, x_20, x_10, x_16); +return x_21; +} +else +{ +uint8_t x_22; +lean_dec(x_14); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_22 = !lean_is_exclusive(x_15); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_23 = lean_ctor_get(x_15, 0); +x_24 = lean_io_error_to_string(x_23); +x_25 = 3; +x_26 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set_uint8(x_26, sizeof(void*)*1, x_25); +x_27 = lean_array_get_size(x_10); +x_28 = lean_array_push(x_10, x_26); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set_tag(x_15, 0); +lean_ctor_set(x_15, 0, x_29); +return x_15; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_30 = lean_ctor_get(x_15, 0); +x_31 = lean_ctor_get(x_15, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_15); +x_32 = lean_io_error_to_string(x_30); +x_33 = 3; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = lean_array_get_size(x_10); +x_36 = lean_array_push(x_10, x_34); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_31); +return x_38; +} +} +} +} +} +static lean_object* _init_l_Lake_compileLeanModule___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(3u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_compileLeanModule___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-R", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-o", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_compileLeanModule___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_2 = l_Lake_compileLeanModule___closed__3; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +_start: +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_14 = l_Lake_compileLeanModule___closed__1; +x_15 = lean_array_push(x_14, x_1); +x_16 = l_Lake_compileLeanModule___closed__2; +x_17 = lean_array_push(x_15, x_16); +x_18 = lean_array_push(x_17, x_7); +x_19 = l_Array_append___rarg(x_10, x_18); +lean_dec(x_18); +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_box(0); +x_21 = l_Lake_compileLeanModule___lambda__7(x_8, x_6, x_9, x_11, x_5, x_4, x_3, x_19, x_20, x_12, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; +x_22 = lean_ctor_get(x_2, 0); +lean_inc(x_22); +lean_dec(x_2); +lean_inc(x_22); +x_23 = l_Lake_createParentDirs(x_22, x_13); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_24 = lean_ctor_get(x_23, 1); +lean_inc(x_24); +lean_dec(x_23); +x_25 = l_Lake_compileLeanModule___closed__4; +x_26 = lean_array_push(x_25, x_22); +x_27 = l_Array_append___rarg(x_19, x_26); +lean_dec(x_26); +x_28 = lean_box(0); +x_29 = l_Lake_compileLeanModule___lambda__7(x_8, x_6, x_9, x_11, x_5, x_4, x_3, x_27, x_28, x_12, x_24); +return x_29; +} +else +{ +uint8_t x_30; +lean_dec(x_22); +lean_dec(x_19); +lean_dec(x_11); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +x_30 = !lean_is_exclusive(x_23); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_31 = lean_ctor_get(x_23, 0); +x_32 = lean_io_error_to_string(x_31); +x_33 = 3; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = lean_array_get_size(x_12); +x_36 = lean_array_push(x_12, x_34); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set_tag(x_23, 0); +lean_ctor_set(x_23, 0, x_37); +return x_23; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_38 = lean_ctor_get(x_23, 0); +x_39 = lean_ctor_get(x_23, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_23); +x_40 = lean_io_error_to_string(x_38); +x_41 = 3; +x_42 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set_uint8(x_42, sizeof(void*)*1, x_41); +x_43 = lean_array_get_size(x_12); +x_44 = lean_array_push(x_12, x_42); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_39); +return x_46; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +size_t x_7; size_t x_8; lean_object* x_9; +x_7 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_8 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_9 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1(x_1, x_7, x_8, x_4, x_5, x_6); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_List_foldlM___at_Lake_compileLeanModule___spec__4___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_compileLeanModule___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_compileLeanModule___lambda__2(x_1, x_2, x_3, x_4); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_compileLeanModule___lambda__3(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_compileLeanModule___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_6); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_compileLeanModule___lambda__5(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_7); +lean_dec(x_1); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; +x_11 = l_Lake_compileLeanModule___lambda__6(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_8); +lean_dec(x_1); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___lambda__7___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; +x_12 = l_Lake_compileLeanModule___lambda__7(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_9); +lean_dec(x_1); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_compileLeanModule___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +_start: +{ +lean_object* x_14; +x_14 = l_Lake_compileLeanModule(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13); +lean_dec(x_8); +return x_14; +} +} +static lean_object* _init_l_Lake_compileO___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(4u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_compileO___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileO___closed__1; +x_2 = l_Lake_compileLeanModule___lambda__6___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_compileO___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileO___closed__2; +x_2 = l_Lake_compileLeanModule___closed__3; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_compileO___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_compileO(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +lean_inc(x_1); +x_7 = l_Lake_createParentDirs(x_1, x_6); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; +x_8 = lean_ctor_get(x_7, 1); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lake_compileO___closed__3; +x_10 = lean_array_push(x_9, x_1); +x_11 = lean_array_push(x_10, x_2); +x_12 = l_Array_append___rarg(x_11, x_3); +x_13 = lean_box(0); +x_14 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_15 = l_Lake_compileO___closed__4; +x_16 = 0; +x_17 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_17, 0, x_14); +lean_ctor_set(x_17, 1, x_4); +lean_ctor_set(x_17, 2, x_12); +lean_ctor_set(x_17, 3, x_13); +lean_ctor_set(x_17, 4, x_15); +lean_ctor_set_uint8(x_17, sizeof(void*)*5, x_16); +x_18 = l_Lake_proc(x_17, x_16, x_5, x_8); +return x_18; +} +else +{ +uint8_t x_19; +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_19 = !lean_is_exclusive(x_7); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_20 = lean_ctor_get(x_7, 0); +x_21 = lean_io_error_to_string(x_20); +x_22 = 3; +x_23 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set_uint8(x_23, sizeof(void*)*1, x_22); +x_24 = lean_array_get_size(x_5); +x_25 = lean_array_push(x_5, x_23); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +lean_ctor_set_tag(x_7, 0); +lean_ctor_set(x_7, 0, x_26); +return x_7; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_27 = lean_ctor_get(x_7, 0); +x_28 = lean_ctor_get(x_7, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_7); +x_29 = lean_io_error_to_string(x_27); +x_30 = 3; +x_31 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set_uint8(x_31, sizeof(void*)*1, x_30); +x_32 = lean_array_get_size(x_5); +x_33 = lean_array_push(x_5, x_31); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_28); +return x_35; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_compileO___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_compileO(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_3); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(size_t x_1, size_t x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = lean_usize_dec_lt(x_2, x_1); +if (x_4 == 0) +{ +return x_3; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; lean_object* x_10; +x_5 = lean_array_uget(x_3, x_2); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_uset(x_3, x_2, x_6); +x_8 = 1; +x_9 = lean_usize_add(x_2, x_8); +x_10 = lean_array_uset(x_7, x_2, x_5); +x_2 = x_9; +x_3 = x_10; +goto _start; +} +} +} +static lean_object* _init_l_Lake_compileStaticLib___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("rcs", 3); +return x_1; +} +} +static lean_object* _init_l_Lake_compileStaticLib___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileLeanModule___lambda__4___closed__4; +x_2 = l_Lake_compileStaticLib___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_compileStaticLib(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +lean_inc(x_1); +x_6 = l_Lake_createParentDirs(x_1, x_5); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; size_t x_11; size_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; +x_7 = lean_ctor_get(x_6, 1); +lean_inc(x_7); +lean_dec(x_6); +x_8 = l_Lake_compileStaticLib___closed__2; +x_9 = lean_array_push(x_8, x_1); +x_10 = lean_array_get_size(x_2); +x_11 = lean_usize_of_nat(x_10); +lean_dec(x_10); +x_12 = 0; +x_13 = l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(x_11, x_12, x_2); +x_14 = l_Array_append___rarg(x_9, x_13); +lean_dec(x_13); +x_15 = lean_box(0); +x_16 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_17 = l_Lake_compileO___closed__4; +x_18 = 0; +x_19 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_19, 0, x_16); +lean_ctor_set(x_19, 1, x_3); +lean_ctor_set(x_19, 2, x_14); +lean_ctor_set(x_19, 3, x_15); +lean_ctor_set(x_19, 4, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*5, x_18); +x_20 = l_Lake_proc(x_19, x_18, x_4, x_7); +return x_20; +} +else +{ +uint8_t x_21; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_22 = lean_ctor_get(x_6, 0); +x_23 = lean_io_error_to_string(x_22); +x_24 = 3; +x_25 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set_uint8(x_25, sizeof(void*)*1, x_24); +x_26 = lean_array_get_size(x_4); +x_27 = lean_array_push(x_4, x_25); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +lean_ctor_set_tag(x_6, 0); +lean_ctor_set(x_6, 0, x_28); +return x_6; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_29 = lean_ctor_get(x_6, 0); +x_30 = lean_ctor_get(x_6, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_6); +x_31 = lean_io_error_to_string(x_29); +x_32 = 3; +x_33 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set_uint8(x_33, sizeof(void*)*1, x_32); +x_34 = lean_array_get_size(x_4); +x_35 = lean_array_push(x_4, x_33); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_30); +return x_37; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +size_t x_4; size_t x_5; lean_object* x_6; +x_4 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(x_4, x_5, x_3); +return x_6; +} +} +static lean_object* _init_l_Lake_compileSharedLib___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-shared", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_compileSharedLib___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileLeanModule___closed__1; +x_2 = l_Lake_compileSharedLib___closed__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_compileSharedLib___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_compileSharedLib___closed__2; +x_2 = l_Lake_compileLeanModule___closed__3; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_compileSharedLib(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +lean_inc(x_1); +x_6 = l_Lake_createParentDirs(x_1, x_5); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_7 = lean_ctor_get(x_6, 1); +lean_inc(x_7); +lean_dec(x_6); +x_8 = l_Lake_compileSharedLib___closed__3; +x_9 = lean_array_push(x_8, x_1); +x_10 = l_Array_append___rarg(x_9, x_2); +x_11 = lean_box(0); +x_12 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_13 = l_Lake_compileO___closed__4; +x_14 = 0; +x_15 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_15, 0, x_12); +lean_ctor_set(x_15, 1, x_3); +lean_ctor_set(x_15, 2, x_10); +lean_ctor_set(x_15, 3, x_11); +lean_ctor_set(x_15, 4, x_13); +lean_ctor_set_uint8(x_15, sizeof(void*)*5, x_14); +x_16 = l_Lake_proc(x_15, x_14, x_4, x_7); +return x_16; +} +else +{ +uint8_t x_17; +lean_dec(x_3); +lean_dec(x_1); +x_17 = !lean_is_exclusive(x_6); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_18 = lean_ctor_get(x_6, 0); +x_19 = lean_io_error_to_string(x_18); +x_20 = 3; +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_20); +x_22 = lean_array_get_size(x_4); +x_23 = lean_array_push(x_4, x_21); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +lean_ctor_set_tag(x_6, 0); +lean_ctor_set(x_6, 0, x_24); +return x_6; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_25 = lean_ctor_get(x_6, 0); +x_26 = lean_ctor_get(x_6, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_6); +x_27 = lean_io_error_to_string(x_25); +x_28 = 3; +x_29 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set_uint8(x_29, sizeof(void*)*1, x_28); +x_30 = lean_array_get_size(x_4); +x_31 = lean_array_push(x_4, x_29); +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_31); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_26); +return x_33; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_compileSharedLib___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_compileSharedLib(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_compileExe(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +lean_inc(x_1); +x_7 = l_Lake_createParentDirs(x_1, x_6); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; size_t x_12; size_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; +x_8 = lean_ctor_get(x_7, 1); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lake_compileLeanModule___closed__4; +x_10 = lean_array_push(x_9, x_1); +x_11 = lean_array_get_size(x_2); +x_12 = lean_usize_of_nat(x_11); +lean_dec(x_11); +x_13 = 0; +x_14 = l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(x_12, x_13, x_2); +x_15 = l_Array_append___rarg(x_10, x_14); +lean_dec(x_14); +x_16 = l_Array_append___rarg(x_15, x_3); +x_17 = lean_box(0); +x_18 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_19 = l_Lake_compileO___closed__4; +x_20 = 0; +x_21 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_21, 0, x_18); +lean_ctor_set(x_21, 1, x_4); +lean_ctor_set(x_21, 2, x_16); +lean_ctor_set(x_21, 3, x_17); +lean_ctor_set(x_21, 4, x_19); +lean_ctor_set_uint8(x_21, sizeof(void*)*5, x_20); +x_22 = l_Lake_proc(x_21, x_20, x_5, x_8); +return x_22; +} +else +{ +uint8_t x_23; +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_23 = !lean_is_exclusive(x_7); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_24 = lean_ctor_get(x_7, 0); +x_25 = lean_io_error_to_string(x_24); +x_26 = 3; +x_27 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set_uint8(x_27, sizeof(void*)*1, x_26); +x_28 = lean_array_get_size(x_5); +x_29 = lean_array_push(x_5, x_27); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +lean_ctor_set_tag(x_7, 0); +lean_ctor_set(x_7, 0, x_30); +return x_7; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_7, 0); +x_32 = lean_ctor_get(x_7, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_7); +x_33 = lean_io_error_to_string(x_31); +x_34 = 3; +x_35 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set_uint8(x_35, sizeof(void*)*1, x_34); +x_36 = lean_array_get_size(x_5); +x_37 = lean_array_push(x_5, x_35); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_32); +return x_39; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_compileExe___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_compileExe(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_3); +return x_7; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(7u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-s", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_download___lambda__1___closed__1; +x_2 = l_Lake_download___lambda__1___closed__2; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-S", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_download___lambda__1___closed__3; +x_2 = l_Lake_download___lambda__1___closed__4; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-f", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_download___lambda__1___closed__5; +x_2 = l_Lake_download___lambda__1___closed__6; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_download___lambda__1___closed__7; +x_2 = l_Lake_compileLeanModule___closed__3; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-L", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_download___lambda__1___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("curl", 4); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_download___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; +x_6 = l_Lake_download___lambda__1___closed__8; +x_7 = lean_array_push(x_6, x_1); +x_8 = l_Lake_download___lambda__1___closed__9; +x_9 = lean_array_push(x_7, x_8); +x_10 = lean_array_push(x_9, x_2); +x_11 = lean_box(0); +x_12 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_13 = l_Lake_download___lambda__1___closed__10; +x_14 = l_Lake_compileO___closed__4; +x_15 = 0; +x_16 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_16, 0, x_12); +lean_ctor_set(x_16, 1, x_13); +lean_ctor_set(x_16, 2, x_10); +lean_ctor_set(x_16, 3, x_11); +lean_ctor_set(x_16, 4, x_14); +lean_ctor_set_uint8(x_16, sizeof(void*)*5, x_15); +x_17 = 1; +x_18 = l_Lake_proc(x_16, x_17, x_4, x_5); +return x_18; +} +} +LEAN_EXPORT lean_object* l_Lake_download(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_5 = l_System_FilePath_pathExists(x_2, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_unbox(x_6); +lean_dec(x_6); +if (x_7 == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_5); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_5, 1); +x_10 = lean_ctor_get(x_5, 0); +lean_dec(x_10); +lean_inc(x_2); +x_11 = l_Lake_createParentDirs(x_2, x_9); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_free_object(x_5); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_11, 1); +lean_inc(x_13); +lean_dec(x_11); +x_14 = l_Lake_download___lambda__1(x_2, x_1, x_12, x_3, x_13); +lean_dec(x_12); +return x_14; +} +else +{ +uint8_t x_15; +lean_dec(x_2); +lean_dec(x_1); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_11, 0); +x_17 = lean_io_error_to_string(x_16); +x_18 = 3; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = lean_array_get_size(x_3); +x_21 = lean_array_push(x_3, x_19); +lean_ctor_set_tag(x_5, 1); +lean_ctor_set(x_5, 1, x_21); +lean_ctor_set(x_5, 0, x_20); +lean_ctor_set_tag(x_11, 0); +lean_ctor_set(x_11, 0, x_5); +return x_11; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_11); +x_24 = lean_io_error_to_string(x_22); +x_25 = 3; +x_26 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set_uint8(x_26, sizeof(void*)*1, x_25); +x_27 = lean_array_get_size(x_3); +x_28 = lean_array_push(x_3, x_26); +lean_ctor_set_tag(x_5, 1); +lean_ctor_set(x_5, 1, x_28); +lean_ctor_set(x_5, 0, x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_5); +lean_ctor_set(x_29, 1, x_23); +return x_29; +} +} +} +else +{ +lean_object* x_30; lean_object* x_31; +x_30 = lean_ctor_get(x_5, 1); +lean_inc(x_30); +lean_dec(x_5); +lean_inc(x_2); +x_31 = l_Lake_createParentDirs(x_2, x_30); +if (lean_obj_tag(x_31) == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_31, 1); +lean_inc(x_33); +lean_dec(x_31); +x_34 = l_Lake_download___lambda__1(x_2, x_1, x_32, x_3, x_33); +lean_dec(x_32); +return x_34; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_2); +lean_dec(x_1); +x_35 = lean_ctor_get(x_31, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_31, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_37 = x_31; +} else { + lean_dec_ref(x_31); + x_37 = lean_box(0); +} +x_38 = lean_io_error_to_string(x_35); +x_39 = 3; +x_40 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set_uint8(x_40, sizeof(void*)*1, x_39); +x_41 = lean_array_get_size(x_3); +x_42 = lean_array_push(x_3, x_40); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +if (lean_is_scalar(x_37)) { + x_44 = lean_alloc_ctor(0, 2, 0); +} else { + x_44 = x_37; + lean_ctor_set_tag(x_44, 0); +} +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_36); +return x_44; +} +} +} +else +{ +uint8_t x_45; +x_45 = !lean_is_exclusive(x_5); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_5, 1); +x_47 = lean_ctor_get(x_5, 0); +lean_dec(x_47); +x_48 = lean_io_remove_file(x_2, x_46); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_free_object(x_5); +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_48, 1); +lean_inc(x_50); +lean_dec(x_48); +x_51 = l_Lake_download___lambda__1(x_2, x_1, x_49, x_3, x_50); +lean_dec(x_49); +return x_51; +} +else +{ +uint8_t x_52; +lean_dec(x_2); +lean_dec(x_1); +x_52 = !lean_is_exclusive(x_48); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_53 = lean_ctor_get(x_48, 0); +x_54 = lean_io_error_to_string(x_53); +x_55 = 3; +x_56 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set_uint8(x_56, sizeof(void*)*1, x_55); +x_57 = lean_array_get_size(x_3); +x_58 = lean_array_push(x_3, x_56); +lean_ctor_set_tag(x_5, 1); +lean_ctor_set(x_5, 1, x_58); +lean_ctor_set(x_5, 0, x_57); +lean_ctor_set_tag(x_48, 0); +lean_ctor_set(x_48, 0, x_5); +return x_48; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_59 = lean_ctor_get(x_48, 0); +x_60 = lean_ctor_get(x_48, 1); +lean_inc(x_60); +lean_inc(x_59); +lean_dec(x_48); +x_61 = lean_io_error_to_string(x_59); +x_62 = 3; +x_63 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set_uint8(x_63, sizeof(void*)*1, x_62); +x_64 = lean_array_get_size(x_3); +x_65 = lean_array_push(x_3, x_63); +lean_ctor_set_tag(x_5, 1); +lean_ctor_set(x_5, 1, x_65); +lean_ctor_set(x_5, 0, x_64); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_5); +lean_ctor_set(x_66, 1, x_60); +return x_66; +} +} +} +else +{ +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_5, 1); +lean_inc(x_67); +lean_dec(x_5); +x_68 = lean_io_remove_file(x_2, x_67); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_68, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_68, 1); +lean_inc(x_70); +lean_dec(x_68); +x_71 = l_Lake_download___lambda__1(x_2, x_1, x_69, x_3, x_70); +lean_dec(x_69); +return x_71; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_dec(x_2); +lean_dec(x_1); +x_72 = lean_ctor_get(x_68, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_68, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_74 = x_68; +} else { + lean_dec_ref(x_68); + x_74 = lean_box(0); +} +x_75 = lean_io_error_to_string(x_72); +x_76 = 3; +x_77 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_77, 0, x_75); +lean_ctor_set_uint8(x_77, sizeof(void*)*1, x_76); +x_78 = lean_array_get_size(x_3); +x_79 = lean_array_push(x_3, x_77); +x_80 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set(x_80, 1, x_79); +if (lean_is_scalar(x_74)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_74; + lean_ctor_set_tag(x_81, 0); +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_73); +return x_81; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_download___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_download___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +return x_6; +} +} +static lean_object* _init_l_Lake_untar___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(5u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_untar___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-C", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_untar___lambda__1___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("tar", 3); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_untar___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; +x_7 = l_Lake_untar___lambda__1___closed__1; +x_8 = lean_array_push(x_7, x_3); +x_9 = l_Lake_download___lambda__1___closed__6; +x_10 = lean_array_push(x_8, x_9); +x_11 = lean_array_push(x_10, x_1); +x_12 = l_Lake_untar___lambda__1___closed__2; +x_13 = lean_array_push(x_11, x_12); +x_14 = lean_array_push(x_13, x_2); +x_15 = lean_box(0); +x_16 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_17 = l_Lake_untar___lambda__1___closed__3; +x_18 = l_Lake_compileO___closed__4; +x_19 = 0; +x_20 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_20, 0, x_16); +lean_ctor_set(x_20, 1, x_17); +lean_ctor_set(x_20, 2, x_14); +lean_ctor_set(x_20, 3, x_15); +lean_ctor_set(x_20, 4, x_18); +lean_ctor_set_uint8(x_20, sizeof(void*)*5, x_19); +x_21 = 1; +x_22 = l_Lake_proc(x_20, x_21, x_5, x_6); +return x_22; +} +} +static lean_object* _init_l_Lake_untar___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-xvv", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_untar___closed__2() { +_start: +{ +uint32_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 122; +x_2 = l_Lake_untar___closed__1; +x_3 = lean_string_push(x_2, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_untar(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_23; +lean_inc(x_2); +x_23 = l_IO_FS_createDirAll(x_2, x_5); +if (lean_obj_tag(x_23) == 0) +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_23); +if (x_24 == 0) +{ +lean_object* x_25; +x_25 = lean_ctor_get(x_23, 1); +lean_ctor_set(x_23, 1, x_4); +x_6 = x_23; +x_7 = x_25; +goto block_22; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_23, 0); +x_27 = lean_ctor_get(x_23, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_23); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_4); +x_6 = x_28; +x_7 = x_27; +goto block_22; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_23); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_30 = lean_ctor_get(x_23, 0); +x_31 = lean_ctor_get(x_23, 1); +x_32 = lean_io_error_to_string(x_30); +x_33 = 3; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = lean_array_get_size(x_4); +x_36 = lean_array_push(x_4, x_34); +lean_ctor_set(x_23, 1, x_36); +lean_ctor_set(x_23, 0, x_35); +x_6 = x_23; +x_7 = x_31; +goto block_22; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_37 = lean_ctor_get(x_23, 0); +x_38 = lean_ctor_get(x_23, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_23); +x_39 = lean_io_error_to_string(x_37); +x_40 = 3; +x_41 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set_uint8(x_41, sizeof(void*)*1, x_40); +x_42 = lean_array_get_size(x_4); +x_43 = lean_array_push(x_4, x_41); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +x_6 = x_44; +x_7 = x_38; +goto block_22; +} +} +block_22: +{ +if (lean_obj_tag(x_6) == 0) +{ +if (x_3 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_6, 1); +lean_inc(x_8); +lean_dec(x_6); +x_9 = l_Lake_untar___closed__1; +x_10 = lean_box(0); +x_11 = l_Lake_untar___lambda__1(x_1, x_2, x_9, x_10, x_8, x_7); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_6, 1); +lean_inc(x_12); +lean_dec(x_6); +x_13 = l_Lake_untar___closed__2; +x_14 = lean_box(0); +x_15 = l_Lake_untar___lambda__1(x_1, x_2, x_13, x_14, x_12, x_7); +return x_15; +} +} +else +{ +uint8_t x_16; +lean_dec(x_2); +lean_dec(x_1); +x_16 = !lean_is_exclusive(x_6); +if (x_16 == 0) +{ +lean_object* x_17; +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_6); +lean_ctor_set(x_17, 1, x_7); +return x_17; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_6, 0); +x_19 = lean_ctor_get(x_6, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_6); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_7); +return x_21; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_untar___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_untar___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_untar___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_3); +lean_dec(x_3); +x_7 = l_Lake_untar(x_1, x_2, x_6, x_4, x_5); +return x_7; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("--exclude=", 10); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_tar___spec__1(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = lean_usize_dec_lt(x_3, x_2); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_4); +lean_ctor_set(x_8, 1, x_5); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_6); +return x_9; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; +x_10 = lean_array_uget(x_1, x_3); +x_11 = l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___closed__1; +x_12 = lean_string_append(x_11, x_10); +lean_dec(x_10); +x_13 = l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2; +x_14 = lean_string_append(x_12, x_13); +x_15 = lean_array_push(x_4, x_14); +x_16 = 1; +x_17 = lean_usize_add(x_3, x_16); +x_3 = x_17; +x_4 = x_15; +goto _start; +} +} +} +static lean_object* _init_l_Lake_tar___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_untar___lambda__1___closed__1; +x_2 = l_Lake_download___lambda__1___closed__6; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_tar___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("true", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_tar___lambda__1___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_tar___lambda__1___closed__2; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_tar___lambda__1___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("COPYFILE_DISABLE", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_tar___lambda__1___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_tar___lambda__1___closed__4; +x_2 = l_Lake_tar___lambda__1___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_tar___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; size_t x_10; size_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; +x_9 = lean_array_get_size(x_1); +x_10 = lean_usize_of_nat(x_9); +lean_dec(x_9); +x_11 = 0; +x_12 = l_Array_forInUnsafe_loop___at_Lake_tar___spec__1(x_1, x_10, x_11, x_5, x_7, x_8); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = lean_ctor_get(x_13, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_13, 1); +lean_inc(x_16); +lean_dec(x_13); +x_17 = l_Lake_tar___lambda__1___closed__1; +x_18 = lean_array_push(x_17, x_2); +x_19 = l_Lake_untar___lambda__1___closed__2; +x_20 = lean_array_push(x_18, x_19); +x_21 = lean_array_push(x_20, x_3); +x_22 = l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__6; +x_23 = lean_array_push(x_21, x_22); +x_24 = l_Array_append___rarg(x_15, x_23); +lean_dec(x_23); +x_25 = lean_box(0); +x_26 = l_System_Platform_isOSX; +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; +lean_dec(x_4); +x_27 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_28 = l_Lake_untar___lambda__1___closed__3; +x_29 = l_Lake_compileO___closed__4; +x_30 = 0; +x_31 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_31, 0, x_27); +lean_ctor_set(x_31, 1, x_28); +lean_ctor_set(x_31, 2, x_24); +lean_ctor_set(x_31, 3, x_25); +lean_ctor_set(x_31, 4, x_29); +lean_ctor_set_uint8(x_31, sizeof(void*)*5, x_30); +x_32 = 1; +x_33 = l_Lake_proc(x_31, x_32, x_16, x_14); +return x_33; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; +x_34 = l_Lake_tar___lambda__1___closed__5; +x_35 = lean_array_push(x_4, x_34); +x_36 = l_Lake_compileLeanModule___lambda__4___closed__2; +x_37 = l_Lake_untar___lambda__1___closed__3; +x_38 = 0; +x_39 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_39, 0, x_36); +lean_ctor_set(x_39, 1, x_37); +lean_ctor_set(x_39, 2, x_24); +lean_ctor_set(x_39, 3, x_25); +lean_ctor_set(x_39, 4, x_35); +lean_ctor_set_uint8(x_39, sizeof(void*)*5, x_38); +x_40 = 1; +x_41 = l_Lake_proc(x_39, x_40, x_16, x_14); +return x_41; +} +} +} +static lean_object* _init_l_Lake_tar___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_tar___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-cvv", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_tar___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_tar___closed__1; +x_2 = l_Lake_tar___closed__2; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_tar___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-z", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_tar___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_tar___closed__3; +x_2 = l_Lake_tar___closed__4; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_tar(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_26; +lean_inc(x_2); +x_26 = l_Lake_createParentDirs(x_2, x_6); +if (lean_obj_tag(x_26) == 0) +{ +uint8_t x_27; +x_27 = !lean_is_exclusive(x_26); +if (x_27 == 0) +{ +lean_object* x_28; +x_28 = lean_ctor_get(x_26, 1); +lean_ctor_set(x_26, 1, x_5); +x_7 = x_26; +x_8 = x_28; +goto block_25; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_26, 0); +x_30 = lean_ctor_get(x_26, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_26); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_5); +x_7 = x_31; +x_8 = x_30; +goto block_25; +} +} +else +{ +uint8_t x_32; +x_32 = !lean_is_exclusive(x_26); +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_33 = lean_ctor_get(x_26, 0); +x_34 = lean_ctor_get(x_26, 1); +x_35 = lean_io_error_to_string(x_33); +x_36 = 3; +x_37 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set_uint8(x_37, sizeof(void*)*1, x_36); +x_38 = lean_array_get_size(x_5); +x_39 = lean_array_push(x_5, x_37); +lean_ctor_set(x_26, 1, x_39); +lean_ctor_set(x_26, 0, x_38); +x_7 = x_26; +x_8 = x_34; +goto block_25; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_40 = lean_ctor_get(x_26, 0); +x_41 = lean_ctor_get(x_26, 1); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_26); +x_42 = lean_io_error_to_string(x_40); +x_43 = 3; +x_44 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set_uint8(x_44, sizeof(void*)*1, x_43); +x_45 = lean_array_get_size(x_5); +x_46 = lean_array_push(x_5, x_44); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +x_7 = x_47; +x_8 = x_41; +goto block_25; +} +} +block_25: +{ +if (lean_obj_tag(x_7) == 0) +{ +if (x_3 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = l_Lake_tar___closed__1; +x_11 = l_Lake_tar___closed__3; +x_12 = lean_box(0); +x_13 = l_Lake_tar___lambda__1(x_4, x_2, x_1, x_10, x_11, x_12, x_9, x_8); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_14 = lean_ctor_get(x_7, 1); +lean_inc(x_14); +lean_dec(x_7); +x_15 = l_Lake_tar___closed__1; +x_16 = l_Lake_tar___closed__5; +x_17 = lean_box(0); +x_18 = l_Lake_tar___lambda__1(x_4, x_2, x_1, x_15, x_16, x_17, x_14, x_8); +return x_18; +} +} +else +{ +uint8_t x_19; +lean_dec(x_2); +lean_dec(x_1); +x_19 = !lean_is_exclusive(x_7); +if (x_19 == 0) +{ +lean_object* x_20; +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_7); +lean_ctor_set(x_20, 1, x_8); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_7, 0); +x_22 = lean_ctor_get(x_7, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_7); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_8); +return x_24; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +size_t x_7; size_t x_8; lean_object* x_9; +x_7 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_8 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_9 = l_Array_forInUnsafe_loop___at_Lake_tar___spec__1(x_1, x_7, x_8, x_4, x_5, x_6); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_tar___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_tar___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_6); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_tar___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_3); +lean_dec(x_3); +x_8 = l_Lake_tar(x_1, x_2, x_7, x_4, x_5, x_6); +lean_dec(x_4); +return x_8; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Proc(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_NativeLib(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_IO(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Actions(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Proc(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_NativeLib(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_IO(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__1); +l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2 = _init_l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_compileLeanModule___spec__1___closed__2); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__1 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__1(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__1); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__2 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__2(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__2); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__3 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__3(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__3); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__4 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__4(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__4); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__5 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__5(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__5); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__6 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__6(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__6); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__7); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__8 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__8(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__8); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__9 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__9(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__9); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__10 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__10(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__10); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__11); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__12 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__12(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__12); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__13 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__13(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__13); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__14 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__14(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__14); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__15 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__15(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__15); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__16 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__16(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__16); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__17 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__17(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__17); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__18 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__18(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__18); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__19 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__19(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__19); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__20 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__20(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__20); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__21 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__21(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__21); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__22 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__22(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__22); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__23 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__23(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__23); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__24 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__24(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__24); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__25 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__25(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__25); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__26 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__26(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__26); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__27 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__27(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__27); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__28 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__28(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__28); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__29 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__29(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__29); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__30 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__30(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__30); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__31 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__31(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__31); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__32 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__32(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__32); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__33 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__33(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__33); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__34 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__34(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__34); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__35 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__35(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__35); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__36 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__36(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__36); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__37 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__37(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__37); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__38 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__38(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__38); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__39 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__39(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__39); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__40 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__40(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__40); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__41 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__41(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__41); +l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__42 = _init_l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__42(); +lean_mark_persistent(l___private_Lean_Message_0__Lean_fromJsonBaseMessage____x40_Lean_Message___hyg_2574____at_Lake_compileLeanModule___spec__2___closed__42); +l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3___closed__1 = _init_l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3___closed__1(); +lean_mark_persistent(l_Lake_logSerialMessage___at_Lake_compileLeanModule___spec__3___closed__1); +l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1 = _init_l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1(); +lean_mark_persistent(l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__1); +l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2 = _init_l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2(); +lean_mark_persistent(l_List_foldlM___at_Lake_compileLeanModule___spec__4___closed__2); +l_Lake_compileLeanModule___lambda__1___closed__1 = _init_l_Lake_compileLeanModule___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__1___closed__1); +l_Lake_compileLeanModule___lambda__2___closed__1 = _init_l_Lake_compileLeanModule___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__2___closed__1); +l_Lake_compileLeanModule___lambda__3___closed__1 = _init_l_Lake_compileLeanModule___lambda__3___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__3___closed__1); +l_Lake_compileLeanModule___lambda__3___closed__2 = _init_l_Lake_compileLeanModule___lambda__3___closed__2(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__3___closed__2); +l_Lake_compileLeanModule___lambda__4___closed__1 = _init_l_Lake_compileLeanModule___lambda__4___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__4___closed__1); +l_Lake_compileLeanModule___lambda__4___closed__2 = _init_l_Lake_compileLeanModule___lambda__4___closed__2(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__4___closed__2); +l_Lake_compileLeanModule___lambda__4___closed__3 = _init_l_Lake_compileLeanModule___lambda__4___closed__3(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__4___closed__3); +l_Lake_compileLeanModule___lambda__4___closed__4 = _init_l_Lake_compileLeanModule___lambda__4___closed__4(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__4___closed__4); +l_Lake_compileLeanModule___lambda__5___closed__1 = _init_l_Lake_compileLeanModule___lambda__5___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__5___closed__1); +l_Lake_compileLeanModule___lambda__5___closed__2 = _init_l_Lake_compileLeanModule___lambda__5___closed__2(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__5___closed__2); +l_Lake_compileLeanModule___lambda__6___closed__1 = _init_l_Lake_compileLeanModule___lambda__6___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__6___closed__1); +l_Lake_compileLeanModule___lambda__6___closed__2 = _init_l_Lake_compileLeanModule___lambda__6___closed__2(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__6___closed__2); +l_Lake_compileLeanModule___lambda__7___closed__1 = _init_l_Lake_compileLeanModule___lambda__7___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__7___closed__1); +l_Lake_compileLeanModule___lambda__7___closed__2 = _init_l_Lake_compileLeanModule___lambda__7___closed__2(); +lean_mark_persistent(l_Lake_compileLeanModule___lambda__7___closed__2); +l_Lake_compileLeanModule___closed__1 = _init_l_Lake_compileLeanModule___closed__1(); +lean_mark_persistent(l_Lake_compileLeanModule___closed__1); +l_Lake_compileLeanModule___closed__2 = _init_l_Lake_compileLeanModule___closed__2(); +lean_mark_persistent(l_Lake_compileLeanModule___closed__2); +l_Lake_compileLeanModule___closed__3 = _init_l_Lake_compileLeanModule___closed__3(); +lean_mark_persistent(l_Lake_compileLeanModule___closed__3); +l_Lake_compileLeanModule___closed__4 = _init_l_Lake_compileLeanModule___closed__4(); +lean_mark_persistent(l_Lake_compileLeanModule___closed__4); +l_Lake_compileO___closed__1 = _init_l_Lake_compileO___closed__1(); +lean_mark_persistent(l_Lake_compileO___closed__1); +l_Lake_compileO___closed__2 = _init_l_Lake_compileO___closed__2(); +lean_mark_persistent(l_Lake_compileO___closed__2); +l_Lake_compileO___closed__3 = _init_l_Lake_compileO___closed__3(); +lean_mark_persistent(l_Lake_compileO___closed__3); +l_Lake_compileO___closed__4 = _init_l_Lake_compileO___closed__4(); +lean_mark_persistent(l_Lake_compileO___closed__4); +l_Lake_compileStaticLib___closed__1 = _init_l_Lake_compileStaticLib___closed__1(); +lean_mark_persistent(l_Lake_compileStaticLib___closed__1); +l_Lake_compileStaticLib___closed__2 = _init_l_Lake_compileStaticLib___closed__2(); +lean_mark_persistent(l_Lake_compileStaticLib___closed__2); +l_Lake_compileSharedLib___closed__1 = _init_l_Lake_compileSharedLib___closed__1(); +lean_mark_persistent(l_Lake_compileSharedLib___closed__1); +l_Lake_compileSharedLib___closed__2 = _init_l_Lake_compileSharedLib___closed__2(); +lean_mark_persistent(l_Lake_compileSharedLib___closed__2); +l_Lake_compileSharedLib___closed__3 = _init_l_Lake_compileSharedLib___closed__3(); +lean_mark_persistent(l_Lake_compileSharedLib___closed__3); +l_Lake_download___lambda__1___closed__1 = _init_l_Lake_download___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__1); +l_Lake_download___lambda__1___closed__2 = _init_l_Lake_download___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__2); +l_Lake_download___lambda__1___closed__3 = _init_l_Lake_download___lambda__1___closed__3(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__3); +l_Lake_download___lambda__1___closed__4 = _init_l_Lake_download___lambda__1___closed__4(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__4); +l_Lake_download___lambda__1___closed__5 = _init_l_Lake_download___lambda__1___closed__5(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__5); +l_Lake_download___lambda__1___closed__6 = _init_l_Lake_download___lambda__1___closed__6(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__6); +l_Lake_download___lambda__1___closed__7 = _init_l_Lake_download___lambda__1___closed__7(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__7); +l_Lake_download___lambda__1___closed__8 = _init_l_Lake_download___lambda__1___closed__8(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__8); +l_Lake_download___lambda__1___closed__9 = _init_l_Lake_download___lambda__1___closed__9(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__9); +l_Lake_download___lambda__1___closed__10 = _init_l_Lake_download___lambda__1___closed__10(); +lean_mark_persistent(l_Lake_download___lambda__1___closed__10); +l_Lake_untar___lambda__1___closed__1 = _init_l_Lake_untar___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_untar___lambda__1___closed__1); +l_Lake_untar___lambda__1___closed__2 = _init_l_Lake_untar___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_untar___lambda__1___closed__2); +l_Lake_untar___lambda__1___closed__3 = _init_l_Lake_untar___lambda__1___closed__3(); +lean_mark_persistent(l_Lake_untar___lambda__1___closed__3); +l_Lake_untar___closed__1 = _init_l_Lake_untar___closed__1(); +lean_mark_persistent(l_Lake_untar___closed__1); +l_Lake_untar___closed__2 = _init_l_Lake_untar___closed__2(); +lean_mark_persistent(l_Lake_untar___closed__2); +l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_tar___spec__1___closed__1); +l_Lake_tar___lambda__1___closed__1 = _init_l_Lake_tar___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_tar___lambda__1___closed__1); +l_Lake_tar___lambda__1___closed__2 = _init_l_Lake_tar___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_tar___lambda__1___closed__2); +l_Lake_tar___lambda__1___closed__3 = _init_l_Lake_tar___lambda__1___closed__3(); +lean_mark_persistent(l_Lake_tar___lambda__1___closed__3); +l_Lake_tar___lambda__1___closed__4 = _init_l_Lake_tar___lambda__1___closed__4(); +lean_mark_persistent(l_Lake_tar___lambda__1___closed__4); +l_Lake_tar___lambda__1___closed__5 = _init_l_Lake_tar___lambda__1___closed__5(); +lean_mark_persistent(l_Lake_tar___lambda__1___closed__5); +l_Lake_tar___closed__1 = _init_l_Lake_tar___closed__1(); +lean_mark_persistent(l_Lake_tar___closed__1); +l_Lake_tar___closed__2 = _init_l_Lake_tar___closed__2(); +lean_mark_persistent(l_Lake_tar___closed__2); +l_Lake_tar___closed__3 = _init_l_Lake_tar___closed__3(); +lean_mark_persistent(l_Lake_tar___closed__3); +l_Lake_tar___closed__4 = _init_l_Lake_tar___closed__4(); +lean_mark_persistent(l_Lake_tar___closed__4); +l_Lake_tar___closed__5 = _init_l_Lake_tar___closed__5(); +lean_mark_persistent(l_Lake_tar___closed__5); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Basic.c b/stage0/stdlib/Lake/Build/Basic.c new file mode 100644 index 0000000000..98ca7e9468 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Basic.c @@ -0,0 +1,741 @@ +// Lean compiler output +// Module: Lake.Build.Basic +// Imports: Init Lake.Util.Log Lake.Util.Exit Lake.Util.Lift Lake.Config.Context Lake.Build.Trace +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_getNoBuild___rarg___closed__1; +LEAN_EXPORT uint8_t l_Lake_BuildConfig_trustHash___default; +LEAN_EXPORT lean_object* l_Lake_getIsQuiet(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getIsQuiet___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_nonemptyType; +LEAN_EXPORT lean_object* l_Lake_getLeanTrace___rarg(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lake_BuildConfig_noBuild___default; +LEAN_EXPORT lean_object* l_Lake_getIsOldMode___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildConfig_outLv___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getIsVerbose___rarg(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lake_getVerbosity___rarg___lambda__1(lean_object*); +static lean_object* l_Lake_getBuildConfig___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_getIsQuiet___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_getTrustHash(lean_object*); +LEAN_EXPORT lean_object* l_Lake_logStep___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_getBuildConfig___rarg___lambda__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getVerbosity___rarg(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lake_BuildConfig_failLv___default; +LEAN_EXPORT uint8_t l_Lake_BuildConfig_oldMode___default; +LEAN_EXPORT lean_object* l_Lake_getLeanTrace___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildConfig_out___default; +LEAN_EXPORT lean_object* l_Lake_getBuildContext___rarg___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getLeanTrace___rarg___lambda__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getBuildConfig___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getNoBuild___rarg(lean_object*, lean_object*); +uint8_t l_Lake_Verbosity_minLogLv(uint8_t); +LEAN_EXPORT lean_object* l_Lake_getIsOldMode___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT uint8_t l_Lake_BuildConfig_verbosity___default; +LEAN_EXPORT uint8_t l_Lake_BuildConfig_outLv(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getBuildContext(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getVerbosity(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getBuildConfig___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_getIsOldMode___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_getTrustHash___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT uint8_t l_Lake_BuildConfig_showProgress(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getBuildContext___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getIsVerbose(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildConfig_showProgress___boxed(lean_object*); +LEAN_EXPORT uint8_t l_Lake_getTrustHash___rarg___lambda__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getIsOldMode(lean_object*); +static lean_object* l_Lake_getVerbosity___rarg___closed__1; +uint8_t l_Lake_instDecidableEqVerbosity(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_Lake_getVerbosity___rarg___lambda__1___boxed(lean_object*); +static lean_object* l_Lake_getIsQuiet___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_logStep(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_logStep___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_getIsVerbose___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_getBuildConfig(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getNoBuild___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getTrustHash___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_getTrustHash___rarg___closed__1; +LEAN_EXPORT uint8_t l_Lake_getNoBuild___rarg___lambda__1(lean_object*); +LEAN_EXPORT uint8_t l_Lake_BuildConfig_ansiMode___default; +LEAN_EXPORT uint8_t l_Lake_getIsOldMode___rarg___lambda__1(lean_object*); +LEAN_EXPORT uint8_t l_Lake_getIsVerbose___rarg___lambda__1(uint8_t); +LEAN_EXPORT lean_object* l_Lake_getIsVerbose___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT uint8_t l_Lake_getIsQuiet___rarg___lambda__1(uint8_t); +LEAN_EXPORT lean_object* l_Lake_getNoBuild(lean_object*); +LEAN_EXPORT uint32_t l_Lake_noBuildCode; +LEAN_EXPORT lean_object* l_Lake_getLeanTrace(lean_object*); +static lean_object* l_Lake_getLeanTrace___rarg___closed__1; +static uint32_t _init_l_Lake_noBuildCode() { +_start: +{ +uint32_t x_1; +x_1 = 3; +return x_1; +} +} +static uint8_t _init_l_Lake_BuildConfig_oldMode___default() { +_start: +{ +uint8_t x_1; +x_1 = 0; +return x_1; +} +} +static uint8_t _init_l_Lake_BuildConfig_trustHash___default() { +_start: +{ +uint8_t x_1; +x_1 = 1; +return x_1; +} +} +static uint8_t _init_l_Lake_BuildConfig_noBuild___default() { +_start: +{ +uint8_t x_1; +x_1 = 0; +return x_1; +} +} +static uint8_t _init_l_Lake_BuildConfig_verbosity___default() { +_start: +{ +uint8_t x_1; +x_1 = 1; +return x_1; +} +} +static uint8_t _init_l_Lake_BuildConfig_failLv___default() { +_start: +{ +uint8_t x_1; +x_1 = 3; +return x_1; +} +} +static lean_object* _init_l_Lake_BuildConfig_out___default() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(1); +return x_1; +} +} +static uint8_t _init_l_Lake_BuildConfig_ansiMode___default() { +_start: +{ +uint8_t x_1; +x_1 = 0; +return x_1; +} +} +LEAN_EXPORT uint8_t l_Lake_BuildConfig_outLv(lean_object* x_1) { +_start: +{ +uint8_t x_2; uint8_t x_3; +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*1 + 3); +x_3 = l_Lake_Verbosity_minLogLv(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildConfig_outLv___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lake_BuildConfig_outLv(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +LEAN_EXPORT uint8_t l_Lake_BuildConfig_showProgress(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*1 + 2); +if (x_2 == 0) +{ +uint8_t x_3; uint8_t x_4; uint8_t x_5; +x_3 = lean_ctor_get_uint8(x_1, sizeof(void*)*1 + 3); +x_4 = 0; +x_5 = l_Lake_instDecidableEqVerbosity(x_3, x_4); +if (x_5 == 0) +{ +uint8_t x_6; +x_6 = 1; +return x_6; +} +else +{ +uint8_t x_7; +x_7 = 0; +return x_7; +} +} +else +{ +uint8_t x_8; uint8_t x_9; uint8_t x_10; +x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*1 + 3); +x_9 = 2; +x_10 = l_Lake_instDecidableEqVerbosity(x_8, x_9); +if (x_10 == 0) +{ +uint8_t x_11; uint8_t x_12; +x_11 = 0; +x_12 = l_Lake_instDecidableEqVerbosity(x_8, x_11); +if (x_12 == 0) +{ +uint8_t x_13; +x_13 = 1; +return x_13; +} +else +{ +uint8_t x_14; +x_14 = 0; +return x_14; +} +} +else +{ +uint8_t x_15; +x_15 = 1; +return x_15; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildConfig_showProgress___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lake_BuildConfig_showProgress(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_OpaqueJob_nonemptyType() { +_start: +{ +return lean_box(0); +} +} +LEAN_EXPORT lean_object* l_Lake_getBuildContext___rarg(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getBuildContext(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getBuildContext___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getBuildContext___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_getBuildContext___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getLeanTrace___rarg___lambda__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_ctor_get(x_1, 2); +lean_inc(x_2); +return x_2; +} +} +static lean_object* _init_l_Lake_getLeanTrace___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getLeanTrace___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getLeanTrace___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getLeanTrace___rarg___closed__1; +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_getLeanTrace(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getLeanTrace___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getLeanTrace___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_getLeanTrace___rarg___lambda__1(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getBuildConfig___rarg___lambda__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +return x_2; +} +} +static lean_object* _init_l_Lake_getBuildConfig___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getBuildConfig___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getBuildConfig___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getBuildConfig___rarg___closed__1; +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_getBuildConfig(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getBuildConfig___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getBuildConfig___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_getBuildConfig___rarg___lambda__1(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT uint8_t l_Lake_getIsOldMode___rarg___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*1); +return x_2; +} +} +static lean_object* _init_l_Lake_getIsOldMode___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getIsOldMode___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsOldMode___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getBuildConfig___rarg___closed__1; +lean_inc(x_3); +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +x_6 = l_Lake_getIsOldMode___rarg___closed__1; +x_7 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_6, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsOldMode(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getIsOldMode___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsOldMode___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lake_getIsOldMode___rarg___lambda__1(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +LEAN_EXPORT uint8_t l_Lake_getTrustHash___rarg___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*1 + 1); +return x_2; +} +} +static lean_object* _init_l_Lake_getTrustHash___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getTrustHash___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getTrustHash___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getBuildConfig___rarg___closed__1; +lean_inc(x_3); +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +x_6 = l_Lake_getTrustHash___rarg___closed__1; +x_7 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_6, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_getTrustHash(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getTrustHash___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getTrustHash___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lake_getTrustHash___rarg___lambda__1(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +LEAN_EXPORT uint8_t l_Lake_getNoBuild___rarg___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*1 + 2); +return x_2; +} +} +static lean_object* _init_l_Lake_getNoBuild___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getNoBuild___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getNoBuild___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getBuildConfig___rarg___closed__1; +lean_inc(x_3); +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +x_6 = l_Lake_getNoBuild___rarg___closed__1; +x_7 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_6, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_getNoBuild(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getNoBuild___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getNoBuild___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lake_getNoBuild___rarg___lambda__1(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +LEAN_EXPORT uint8_t l_Lake_getVerbosity___rarg___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*1 + 3); +return x_2; +} +} +static lean_object* _init_l_Lake_getVerbosity___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getVerbosity___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getVerbosity___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getBuildConfig___rarg___closed__1; +lean_inc(x_3); +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +x_6 = l_Lake_getVerbosity___rarg___closed__1; +x_7 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_6, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_getVerbosity(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getVerbosity___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getVerbosity___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lake_getVerbosity___rarg___lambda__1(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +LEAN_EXPORT uint8_t l_Lake_getIsVerbose___rarg___lambda__1(uint8_t x_1) { +_start: +{ +uint8_t x_2; uint8_t x_3; +x_2 = 2; +x_3 = l_Lake_instDecidableEqVerbosity(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_getIsVerbose___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getIsVerbose___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsVerbose___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getBuildConfig___rarg___closed__1; +lean_inc(x_3); +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +x_6 = l_Lake_getVerbosity___rarg___closed__1; +lean_inc(x_3); +x_7 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_6, x_5); +x_8 = l_Lake_getIsVerbose___rarg___closed__1; +x_9 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_8, x_7); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsVerbose(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getIsVerbose___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsVerbose___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; uint8_t x_3; lean_object* x_4; +x_2 = lean_unbox(x_1); +lean_dec(x_1); +x_3 = l_Lake_getIsVerbose___rarg___lambda__1(x_2); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT uint8_t l_Lake_getIsQuiet___rarg___lambda__1(uint8_t x_1) { +_start: +{ +uint8_t x_2; uint8_t x_3; +x_2 = 0; +x_3 = l_Lake_instDecidableEqVerbosity(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_getIsQuiet___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getIsQuiet___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsQuiet___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_getBuildConfig___rarg___closed__1; +lean_inc(x_3); +x_5 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_4, x_2); +x_6 = l_Lake_getVerbosity___rarg___closed__1; +lean_inc(x_3); +x_7 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_6, x_5); +x_8 = l_Lake_getIsQuiet___rarg___closed__1; +x_9 = lean_apply_4(x_3, lean_box(0), lean_box(0), x_8, x_7); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsQuiet(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_getIsQuiet___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getIsQuiet___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; uint8_t x_3; lean_object* x_4; +x_2 = lean_unbox(x_1); +lean_dec(x_1); +x_3 = l_Lake_getIsQuiet___rarg___lambda__1(x_2); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_logStep___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; lean_object* x_5; +x_3 = 0; +x_4 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_4, 0, x_2); +lean_ctor_set_uint8(x_4, sizeof(void*)*1, x_3); +x_5 = lean_apply_1(x_1, x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_logStep(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_logStep___rarg), 2, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_logStep___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_logStep(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Log(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Exit(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Lift(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Config_Context(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Trace(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Basic(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Log(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Exit(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Lift(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Config_Context(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Trace(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_noBuildCode = _init_l_Lake_noBuildCode(); +l_Lake_BuildConfig_oldMode___default = _init_l_Lake_BuildConfig_oldMode___default(); +l_Lake_BuildConfig_trustHash___default = _init_l_Lake_BuildConfig_trustHash___default(); +l_Lake_BuildConfig_noBuild___default = _init_l_Lake_BuildConfig_noBuild___default(); +l_Lake_BuildConfig_verbosity___default = _init_l_Lake_BuildConfig_verbosity___default(); +l_Lake_BuildConfig_failLv___default = _init_l_Lake_BuildConfig_failLv___default(); +l_Lake_BuildConfig_out___default = _init_l_Lake_BuildConfig_out___default(); +lean_mark_persistent(l_Lake_BuildConfig_out___default); +l_Lake_BuildConfig_ansiMode___default = _init_l_Lake_BuildConfig_ansiMode___default(); +l_Lake_OpaqueJob_nonemptyType = _init_l_Lake_OpaqueJob_nonemptyType(); +l_Lake_getLeanTrace___rarg___closed__1 = _init_l_Lake_getLeanTrace___rarg___closed__1(); +lean_mark_persistent(l_Lake_getLeanTrace___rarg___closed__1); +l_Lake_getBuildConfig___rarg___closed__1 = _init_l_Lake_getBuildConfig___rarg___closed__1(); +lean_mark_persistent(l_Lake_getBuildConfig___rarg___closed__1); +l_Lake_getIsOldMode___rarg___closed__1 = _init_l_Lake_getIsOldMode___rarg___closed__1(); +lean_mark_persistent(l_Lake_getIsOldMode___rarg___closed__1); +l_Lake_getTrustHash___rarg___closed__1 = _init_l_Lake_getTrustHash___rarg___closed__1(); +lean_mark_persistent(l_Lake_getTrustHash___rarg___closed__1); +l_Lake_getNoBuild___rarg___closed__1 = _init_l_Lake_getNoBuild___rarg___closed__1(); +lean_mark_persistent(l_Lake_getNoBuild___rarg___closed__1); +l_Lake_getVerbosity___rarg___closed__1 = _init_l_Lake_getVerbosity___rarg___closed__1(); +lean_mark_persistent(l_Lake_getVerbosity___rarg___closed__1); +l_Lake_getIsVerbose___rarg___closed__1 = _init_l_Lake_getIsVerbose___rarg___closed__1(); +lean_mark_persistent(l_Lake_getIsVerbose___rarg___closed__1); +l_Lake_getIsQuiet___rarg___closed__1 = _init_l_Lake_getIsQuiet___rarg___closed__1(); +lean_mark_persistent(l_Lake_getIsQuiet___rarg___closed__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Common.c b/stage0/stdlib/Lake/Build/Common.c new file mode 100644 index 0000000000..9ff6db0c5e --- /dev/null +++ b/stage0/stdlib/Lake/Build/Common.c @@ -0,0 +1,25092 @@ +// Lean compiler output +// Module: Lake.Build.Common +// Imports: Init Lake.Config.Monad Lake.Build.Actions +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +extern lean_object* l_Lake_MTime_instOrd; +LEAN_EXPORT lean_object* l_Lake_readTraceFile_x3f___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_compileO(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_uint32_to_uint8(uint32_t); +LEAN_EXPORT lean_object* l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31_(lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_fetchFileHash___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_fetchFileHash(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Json_mkObj(lean_object*); +lean_object* lean_io_remove_file(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_inputBinFile___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___boxed(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__6; +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepList(lean_object*); +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint64_t lean_uint64_of_nat(lean_object*); +uint64_t lean_uint64_mix_hash(uint64_t, uint64_t); +lean_object* lean_get_set_stdout(lean_object*, lean_object*); +static lean_object* l_Lake_computeDynlibOfShared___lambda__2___closed__1; +lean_object* l_Lake_compileSharedLib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_as_task(lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1; +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__2; +extern uint8_t l_System_Platform_isOSX; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT uint64_t l_Lake_computeArrayHash___at_Lake_buildO___spec__1(lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_computeTextFileHash(lean_object*, lean_object*); +uint8_t lean_usize_dec_eq(size_t, size_t); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildJob_collectList___rarg(lean_object*); +static lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__2; +lean_object* lean_io_metadata(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_inputBinFile___closed__1; +static uint8_t l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1; +static uint64_t l_Lake_platformTrace___closed__1; +lean_object* l_Lake_MTime_checkUpToDate___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_System_FilePath_withExtension(lean_object*, lean_object*); +static uint64_t l_Lake_platformTrace___closed__2; +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__9; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanExe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_instOrdJobAction; +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__4; +uint64_t lean_string_hash(lean_object*); +lean_object* l_List_bindTR_go___at___private_Lake_Util_Log_0__Lake_toJsonLogEntry____x40_Lake_Util_Log___hyg_1315____spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_fetchFileTrace(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_instDecidableRelLt___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +lean_object* l_Lake_computeFileHash(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_instBEqHash; +lean_object* l_System_FilePath_pathExists(lean_object*, lean_object*); +static lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__4; +LEAN_EXPORT lean_object* l_Lake_buildStaticLib(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_readTraceFile_x3f(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildTrace_mix(lean_object*, lean_object*); +uint8_t lean_string_validate_utf8(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_compileExe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3; +static lean_object* l_Lake_readTraceFile_x3f___closed__2; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__3; +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_sharedLibExt; +LEAN_EXPORT uint64_t l_Lake_platformTrace; +LEAN_EXPORT lean_object* l_Lake_inputBinFile(lean_object*, lean_object*, lean_object*); +size_t lean_usize_of_nat(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_String_isEmpty(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepArray(lean_object*); +static lean_object* l_Lake_buildStaticLib___lambda__3___closed__1; +static lean_object* l_Lake_buildO___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_createParentDirs(lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__3; +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_buildFileAfterDep___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_nat_to_int(lean_object*); +LEAN_EXPORT lean_object* l_Lake_fetchFileHash___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_ByteArray_empty; +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1; +LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1(lean_object*); +lean_object* l_Lean_Json_getObjValD(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instFromJsonBuildMetadata; +lean_object* l_Lake_BuildJob_collectArray___rarg(lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__4; +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepList___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_uint64_to_nat(uint64_t); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___lambda__1(lean_object*, lean_object*); +lean_object* lean_st_ref_get(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_computeDynlibOfShared___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_st_mk_ref(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_mapMUnsafe_map___at_Lake_instToJsonLog___spec__1(size_t, size_t, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__7; +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__2(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___lambda__1___boxed(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__3; +uint8_t l_String_startsWith(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_map_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +lean_object* l_panic___at_String_fromUTF8_x21___spec__1(lean_object*); +static lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2; +static lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___closed__1; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildO___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_fetchFileHash___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__10; +LEAN_EXPORT lean_object* l_Lake_cacheFileHash(lean_object*, lean_object*); +lean_object* l_System_FilePath_fileStem(lean_object*); +static lean_object* l_Lake_cacheFileHash___closed__1; +extern lean_object* l_Task_Priority_default; +static lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +lean_object* l_IO_FS_Stream_ofBuffer(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_instMonadBaseIO; +LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1(lean_object*, lean_object*); +static lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__3; +LEAN_EXPORT uint8_t l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(lean_object*, lean_object*); +lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_bignumFromJson_x3f(lean_object*); +extern lean_object* l_Lake_BuildTrace_nil; +static lean_object* l_Lake_buildLeanO___lambda__4___closed__1; +lean_object* lean_get_set_stderr(lean_object*, lean_object*); +static lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__6; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_computeDynlibOfShared___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_from_utf8(lean_object*); +LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__5; +lean_object* l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79_(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_buildFileAfterDep___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildO___lambda__1___closed__2; +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_computeDynlibOfShared___lambda__2___closed__4; +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2; +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__14; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2; +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_IO_FS_readFile(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___boxed(lean_object*, lean_object*); +lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_buildFileAfterDep___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__3; +lean_object* l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildLeanO___closed__1; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepArray___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instToJsonBuildMetadata___closed__1; +LEAN_EXPORT lean_object* l_Lake_inputBinFile___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Hash_load_x3f(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__15; +LEAN_EXPORT lean_object* l_Lake_inputTextFile___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instFromJsonBuildMetadata___closed__1; +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__1; +LEAN_EXPORT lean_object* l_Lake_inputFile(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_readTraceFile_x3f___closed__3; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputBinFile___spec__1___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepArray___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___at_Lake_buildO___spec__1___boxed(lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +extern uint64_t l_Lake_Hash_nil; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__12; +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_computeDynlibOfShared___lambda__2___closed__3; +lean_object* l_Array_mapMUnsafe_map___at_Lake_instFromJsonLog___spec__1(size_t, size_t, lean_object*); +lean_object* lean_io_exit(uint8_t, lean_object*); +uint8_t l_instDecidableRelLe___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepList___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__2___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT uint64_t l_Array_foldlMUnsafe_fold___at_Lake_buildO___spec__2(lean_object*, size_t, size_t, uint64_t); +lean_object* lean_get_set_stdin(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_computeDynlibOfShared___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanO(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_bignumToJson(lean_object*); +LEAN_EXPORT lean_object* l_Lake_inputBinFile___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_uint64_dec_eq(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Lake_instToJsonBuildMetadata; +static lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__13; +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared___lambda__2(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_inputTextFile(lean_object*, lean_object*, lean_object*); +size_t lean_usize_add(size_t, size_t); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__11; +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_uget(lean_object*, size_t); +lean_object* l_Array_foldlMUnsafe_fold___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*); +static lean_object* l_Lake_computeDynlibOfShared___lambda__2___closed__2; +lean_object* l_Lake_compileStaticLib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_error_to_string(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_IO_FS_writeFile(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_writeTraceFile(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildFileUnlessUpToDate___closed__1; +lean_object* lean_string_append(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern uint32_t l_Lake_noBuildCode; +LEAN_EXPORT lean_object* l_Lake_buildO(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +LEAN_EXPORT lean_object* l_Lake_fetchFileTrace___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__2; +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__5; +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__8; +lean_object* l_Lake_EStateT_instMonad___rarg(lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Json_parse(lean_object*); +static lean_object* l_Lake_readTraceFile_x3f___closed__1; +lean_object* l_Lean_Json_pretty(lean_object*, lean_object*); +extern lean_object* l_System_Platform_target; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f(lean_object*); +extern uint8_t l_System_Platform_isWindows; +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_inputTextFile___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l___private_Init_Data_Repr_0__Nat_reprFast(lean_object*); +lean_object* l_String_drop(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildFileUnlessUpToDate(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +LEAN_EXPORT lean_object* l_Lake_clearFileHash(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputBinFile___spec__1(lean_object*, lean_object*); +lean_object* l_ReaderT_instMonad___rarg(lean_object*); +static lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__2; +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static uint64_t _init_l_Lake_platformTrace___closed__1() { +_start: +{ +lean_object* x_1; uint64_t x_2; +x_1 = l_System_Platform_target; +x_2 = lean_string_hash(x_1); +return x_2; +} +} +static uint64_t _init_l_Lake_platformTrace___closed__2() { +_start: +{ +uint64_t x_1; uint64_t x_2; uint64_t x_3; +x_1 = 1723; +x_2 = l_Lake_platformTrace___closed__1; +x_3 = lean_uint64_mix_hash(x_1, x_2); +return x_3; +} +} +static uint64_t _init_l_Lake_platformTrace() { +_start: +{ +uint64_t x_1; +x_1 = l_Lake_platformTrace___closed__2; +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("depHash", 7); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("log", 3); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31_(lean_object* x_1) { +_start: +{ +lean_object* x_2; uint64_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; size_t x_12; size_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = lean_unbox_uint64(x_2); +lean_dec(x_2); +x_4 = lean_uint64_to_nat(x_3); +x_5 = l_Lean_bignumToJson(x_4); +x_6 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1; +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +x_8 = lean_box(0); +x_9 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_9, 0, x_7); +lean_ctor_set(x_9, 1, x_8); +x_10 = lean_ctor_get(x_1, 1); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_array_get_size(x_10); +x_12 = lean_usize_of_nat(x_11); +lean_dec(x_11); +x_13 = 0; +x_14 = l_Array_mapMUnsafe_map___at_Lake_instToJsonLog___spec__1(x_12, x_13, x_10); +x_15 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_15, 0, x_14); +x_16 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2; +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_8); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_8); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_9); +lean_ctor_set(x_20, 1, x_19); +x_21 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__3; +x_22 = l_List_bindTR_go___at___private_Lake_Util_Log_0__Lake_toJsonLogEntry____x40_Lake_Util_Log___hyg_1315____spec__1(x_20, x_21); +x_23 = l_Lean_Json_mkObj(x_22); +return x_23; +} +} +static lean_object* _init_l_Lake_instToJsonBuildMetadata___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31_), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instToJsonBuildMetadata() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instToJsonBuildMetadata___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint64_t x_3; lean_object* x_4; lean_object* x_5; +x_3 = lean_uint64_of_nat(x_1); +x_4 = lean_box_uint64(x_3); +x_5 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_5, 0, x_4); +return x_5; +} +} +static lean_object* _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_cstr_to_nat("18446744073709551616"); +return x_1; +} +} +static lean_object* _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("value '{j}' is too large for `UInt64`", 37); +return x_1; +} +} +static lean_object* _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__2; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = l_Lean_Json_getObjValD(x_1, x_2); +x_4 = l_Lean_bignumFromJson_x3f(x_3); +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_4); +if (x_5 == 0) +{ +return x_4; +} +else +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_7, 0, x_6); +return x_7; +} +} +else +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_8 = lean_ctor_get(x_4, 0); +lean_inc(x_8); +lean_dec(x_4); +x_9 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__1; +x_10 = lean_nat_dec_le(x_9, x_8); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_11 = lean_box(0); +x_12 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___lambda__1(x_8, x_11); +lean_dec(x_8); +x_13 = !lean_is_exclusive(x_12); +if (x_13 == 0) +{ +return x_12; +} +else +{ +lean_object* x_14; lean_object* x_15; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +lean_dec(x_12); +x_15 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_15, 0, x_14); +return x_15; +} +} +else +{ +lean_object* x_16; +lean_dec(x_8); +x_16 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__3; +return x_16; +} +} +} +} +static lean_object* _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("expected JSON array, got '", 26); +return x_1; +} +} +static lean_object* _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("'", 1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lean_Json_getObjValD(x_1, x_2); +switch (lean_obj_tag(x_3)) { +case 0: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_unsigned_to_nat(80u); +x_5 = l_Lean_Json_pretty(x_3, x_4); +x_6 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1; +x_7 = lean_string_append(x_6, x_5); +lean_dec(x_5); +x_8 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2; +x_9 = lean_string_append(x_7, x_8); +x_10 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_10, 0, x_9); +return x_10; +} +case 1: +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_11 = lean_unsigned_to_nat(80u); +x_12 = l_Lean_Json_pretty(x_3, x_11); +x_13 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2; +x_16 = lean_string_append(x_14, x_15); +x_17 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_17, 0, x_16); +return x_17; +} +case 4: +{ +lean_object* x_18; lean_object* x_19; size_t x_20; size_t x_21; lean_object* x_22; +x_18 = lean_ctor_get(x_3, 0); +lean_inc(x_18); +lean_dec(x_3); +x_19 = lean_array_get_size(x_18); +x_20 = lean_usize_of_nat(x_19); +lean_dec(x_19); +x_21 = 0; +x_22 = l_Array_mapMUnsafe_map___at_Lake_instFromJsonLog___spec__1(x_20, x_21, x_18); +if (lean_obj_tag(x_22) == 0) +{ +uint8_t x_23; +x_23 = !lean_is_exclusive(x_22); +if (x_23 == 0) +{ +return x_22; +} +else +{ +lean_object* x_24; lean_object* x_25; +x_24 = lean_ctor_get(x_22, 0); +lean_inc(x_24); +lean_dec(x_22); +x_25 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_25, 0, x_24); +return x_25; +} +} +else +{ +uint8_t x_26; +x_26 = !lean_is_exclusive(x_22); +if (x_26 == 0) +{ +return x_22; +} +else +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_22, 0); +lean_inc(x_27); +lean_dec(x_22); +x_28 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_28, 0, x_27); +return x_28; +} +} +} +default: +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_unsigned_to_nat(80u); +lean_inc(x_3); +x_30 = l_Lean_Json_pretty(x_3, x_29); +x_31 = !lean_is_exclusive(x_3); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_32 = lean_ctor_get(x_3, 0); +lean_dec(x_32); +x_33 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1; +x_34 = lean_string_append(x_33, x_30); +lean_dec(x_30); +x_35 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2; +x_36 = lean_string_append(x_34, x_35); +lean_ctor_set_tag(x_3, 0); +lean_ctor_set(x_3, 0, x_36); +return x_3; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_dec(x_3); +x_37 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1; +x_38 = lean_string_append(x_37, x_30); +lean_dec(x_30); +x_39 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2; +x_40 = lean_string_append(x_38, x_39); +x_41 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_41, 0, x_40); +return x_41; +} +} +} +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake", 4); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("BuildMetadata", 13); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__1; +x_2 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__2; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__4() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__3; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(".", 1); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__4; +x_2 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__5; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__8() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__7; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__6; +x_2 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__8; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": ", 2); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__9; +x_2 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__10; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__13() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__12; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__6; +x_2 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__13; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__15() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__14; +x_2 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__10; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79_(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1; +lean_inc(x_1); +x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +lean_dec(x_1); +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_3, 0); +x_6 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__11; +x_7 = lean_string_append(x_6, x_5); +lean_dec(x_5); +lean_ctor_set(x_3, 0, x_7); +return x_3; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_3, 0); +lean_inc(x_8); +lean_dec(x_3); +x_9 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__11; +x_10 = lean_string_append(x_9, x_8); +lean_dec(x_8); +x_11 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_11, 0, x_10); +return x_11; +} +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_3, 0); +lean_inc(x_12); +lean_dec(x_3); +x_13 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2; +x_14 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2(x_1, x_13); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +lean_dec(x_12); +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 0); +x_17 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__15; +x_18 = lean_string_append(x_17, x_16); +lean_dec(x_16); +lean_ctor_set(x_14, 0, x_18); +return x_14; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_14, 0); +lean_inc(x_19); +lean_dec(x_14); +x_20 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__15; +x_21 = lean_string_append(x_20, x_19); +lean_dec(x_19); +x_22 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_22, 0, x_21); +return x_22; +} +} +else +{ +uint8_t x_23; +x_23 = !lean_is_exclusive(x_14); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; +x_24 = lean_ctor_get(x_14, 0); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_24); +lean_ctor_set(x_14, 0, x_25); +return x_14; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_14, 0); +lean_inc(x_26); +lean_dec(x_14); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_12); +lean_ctor_set(x_27, 1, x_26); +x_28 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_28, 0, x_27); +return x_28; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___lambda__1(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instFromJsonBuildMetadata___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79_), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instFromJsonBuildMetadata() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instFromJsonBuildMetadata___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_readTraceFile_x3f___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_readTraceFile_x3f___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": read failed: ", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_readTraceFile_x3f___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": invalid trace file: ", 22); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_readTraceFile_x3f(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_173; +x_173 = l_IO_FS_readFile(x_1, x_3); +if (lean_obj_tag(x_173) == 0) +{ +uint8_t x_174; +x_174 = !lean_is_exclusive(x_173); +if (x_174 == 0) +{ +lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; +x_175 = lean_ctor_get(x_173, 0); +x_176 = lean_ctor_get(x_173, 1); +x_177 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_177, 0, x_175); +x_178 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_173, 1, x_2); +lean_ctor_set(x_173, 0, x_178); +x_4 = x_173; +x_5 = x_176; +goto block_172; +} +else +{ +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_173, 0); +x_180 = lean_ctor_get(x_173, 1); +lean_inc(x_180); +lean_inc(x_179); +lean_dec(x_173); +x_181 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_181, 0, x_179); +x_182 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_182, 0, 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_2); +x_4 = x_183; +x_5 = x_180; +goto block_172; +} +} +else +{ +uint8_t x_184; +x_184 = !lean_is_exclusive(x_173); +if (x_184 == 0) +{ +lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; +x_185 = lean_ctor_get(x_173, 0); +x_186 = lean_ctor_get(x_173, 1); +x_187 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_187, 0, x_185); +x_188 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_188, 0, x_187); +lean_ctor_set_tag(x_173, 0); +lean_ctor_set(x_173, 1, x_2); +lean_ctor_set(x_173, 0, x_188); +x_4 = x_173; +x_5 = x_186; +goto block_172; +} +else +{ +lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; +x_189 = lean_ctor_get(x_173, 0); +x_190 = lean_ctor_get(x_173, 1); +lean_inc(x_190); +lean_inc(x_189); +lean_dec(x_173); +x_191 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_191, 0, x_189); +x_192 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_192, 0, x_191); +x_193 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_193, 0, x_192); +lean_ctor_set(x_193, 1, x_2); +x_4 = x_193; +x_5 = x_190; +goto block_172; +} +} +block_172: +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_6, 0); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; +lean_free_object(x_6); +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +lean_dec(x_8); +if (lean_obj_tag(x_9) == 11) +{ +uint8_t x_10; +lean_dec(x_9); +x_10 = !lean_is_exclusive(x_4); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_4, 0); +lean_dec(x_11); +x_12 = lean_box(0); +lean_ctor_set(x_4, 0, x_12); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_4); +lean_ctor_set(x_13, 1, x_5); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = lean_ctor_get(x_4, 1); +lean_inc(x_14); +lean_dec(x_4); +x_15 = lean_box(0); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_14); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_5); +return x_17; +} +} +else +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_4); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_19 = lean_ctor_get(x_4, 1); +x_20 = lean_ctor_get(x_4, 0); +lean_dec(x_20); +x_21 = l_Lake_readTraceFile_x3f___closed__1; +x_22 = lean_string_append(x_21, x_1); +x_23 = l_Lake_readTraceFile_x3f___closed__2; +x_24 = lean_string_append(x_22, x_23); +x_25 = lean_io_error_to_string(x_9); +x_26 = lean_string_append(x_24, x_25); +lean_dec(x_25); +x_27 = lean_string_append(x_26, x_21); +x_28 = 2; +x_29 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set_uint8(x_29, sizeof(void*)*1, x_28); +x_30 = lean_array_push(x_19, x_29); +x_31 = lean_box(0); +lean_ctor_set(x_4, 1, x_30); +lean_ctor_set(x_4, 0, x_31); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_4); +lean_ctor_set(x_32, 1, x_5); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_33 = lean_ctor_get(x_4, 1); +lean_inc(x_33); +lean_dec(x_4); +x_34 = l_Lake_readTraceFile_x3f___closed__1; +x_35 = lean_string_append(x_34, x_1); +x_36 = l_Lake_readTraceFile_x3f___closed__2; +x_37 = lean_string_append(x_35, x_36); +x_38 = lean_io_error_to_string(x_9); +x_39 = lean_string_append(x_37, x_38); +lean_dec(x_38); +x_40 = lean_string_append(x_39, x_34); +x_41 = 2; +x_42 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set_uint8(x_42, sizeof(void*)*1, x_41); +x_43 = lean_array_push(x_33, x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_43); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_5); +return x_46; +} +} +} +else +{ +uint8_t x_47; +x_47 = !lean_is_exclusive(x_4); +if (x_47 == 0) +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_48 = lean_ctor_get(x_4, 1); +x_49 = lean_ctor_get(x_4, 0); +lean_dec(x_49); +x_50 = lean_ctor_get(x_8, 0); +lean_inc(x_50); +lean_dec(x_8); +x_51 = l_Lean_Json_parse(x_50); +if (lean_obj_tag(x_51) == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +lean_free_object(x_6); +x_52 = lean_ctor_get(x_51, 0); +lean_inc(x_52); +lean_dec(x_51); +x_53 = l_Lake_readTraceFile_x3f___closed__1; +x_54 = lean_string_append(x_53, x_1); +x_55 = l_Lake_readTraceFile_x3f___closed__3; +x_56 = lean_string_append(x_54, x_55); +x_57 = lean_string_append(x_56, x_52); +lean_dec(x_52); +x_58 = lean_string_append(x_57, x_53); +x_59 = 0; +x_60 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set_uint8(x_60, sizeof(void*)*1, x_59); +x_61 = lean_array_push(x_48, x_60); +x_62 = lean_box(0); +lean_ctor_set(x_4, 1, x_61); +lean_ctor_set(x_4, 0, x_62); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_4); +lean_ctor_set(x_63, 1, x_5); +return x_63; +} +else +{ +lean_object* x_64; lean_object* x_65; +x_64 = lean_ctor_get(x_51, 0); +lean_inc(x_64); +lean_dec(x_51); +x_65 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79_(x_64); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +lean_free_object(x_6); +x_66 = lean_ctor_get(x_65, 0); +lean_inc(x_66); +lean_dec(x_65); +x_67 = l_Lake_readTraceFile_x3f___closed__1; +x_68 = lean_string_append(x_67, x_1); +x_69 = l_Lake_readTraceFile_x3f___closed__3; +x_70 = lean_string_append(x_68, x_69); +x_71 = lean_string_append(x_70, x_66); +lean_dec(x_66); +x_72 = lean_string_append(x_71, x_67); +x_73 = 0; +x_74 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_74, 0, x_72); +lean_ctor_set_uint8(x_74, sizeof(void*)*1, x_73); +x_75 = lean_array_push(x_48, x_74); +x_76 = lean_box(0); +lean_ctor_set(x_4, 1, x_75); +lean_ctor_set(x_4, 0, x_76); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_4); +lean_ctor_set(x_77, 1, x_5); +return x_77; +} +else +{ +lean_object* x_78; lean_object* x_79; +x_78 = lean_ctor_get(x_65, 0); +lean_inc(x_78); +lean_dec(x_65); +lean_ctor_set(x_6, 0, x_78); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_4); +lean_ctor_set(x_79, 1, x_5); +return x_79; +} +} +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_80 = lean_ctor_get(x_4, 1); +lean_inc(x_80); +lean_dec(x_4); +x_81 = lean_ctor_get(x_8, 0); +lean_inc(x_81); +lean_dec(x_8); +x_82 = l_Lean_Json_parse(x_81); +if (lean_obj_tag(x_82) == 0) +{ +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; uint8_t x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_free_object(x_6); +x_83 = lean_ctor_get(x_82, 0); +lean_inc(x_83); +lean_dec(x_82); +x_84 = l_Lake_readTraceFile_x3f___closed__1; +x_85 = lean_string_append(x_84, x_1); +x_86 = l_Lake_readTraceFile_x3f___closed__3; +x_87 = lean_string_append(x_85, x_86); +x_88 = lean_string_append(x_87, x_83); +lean_dec(x_83); +x_89 = lean_string_append(x_88, x_84); +x_90 = 0; +x_91 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set_uint8(x_91, sizeof(void*)*1, x_90); +x_92 = lean_array_push(x_80, x_91); +x_93 = lean_box(0); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_92); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_5); +return x_95; +} +else +{ +lean_object* x_96; lean_object* x_97; +x_96 = lean_ctor_get(x_82, 0); +lean_inc(x_96); +lean_dec(x_82); +x_97 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79_(x_96); +if (lean_obj_tag(x_97) == 0) +{ +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; uint8_t x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; +lean_free_object(x_6); +x_98 = lean_ctor_get(x_97, 0); +lean_inc(x_98); +lean_dec(x_97); +x_99 = l_Lake_readTraceFile_x3f___closed__1; +x_100 = lean_string_append(x_99, x_1); +x_101 = l_Lake_readTraceFile_x3f___closed__3; +x_102 = lean_string_append(x_100, x_101); +x_103 = lean_string_append(x_102, x_98); +lean_dec(x_98); +x_104 = lean_string_append(x_103, x_99); +x_105 = 0; +x_106 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_106, 0, x_104); +lean_ctor_set_uint8(x_106, sizeof(void*)*1, x_105); +x_107 = lean_array_push(x_80, x_106); +x_108 = lean_box(0); +x_109 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_109, 0, x_108); +lean_ctor_set(x_109, 1, x_107); +x_110 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_110, 0, x_109); +lean_ctor_set(x_110, 1, x_5); +return x_110; +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_111 = lean_ctor_get(x_97, 0); +lean_inc(x_111); +lean_dec(x_97); +lean_ctor_set(x_6, 0, x_111); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_6); +lean_ctor_set(x_112, 1, x_80); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_5); +return x_113; +} +} +} +} +} +else +{ +lean_object* x_114; +x_114 = lean_ctor_get(x_6, 0); +lean_inc(x_114); +lean_dec(x_6); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +lean_dec(x_114); +if (lean_obj_tag(x_115) == 11) +{ +lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; +lean_dec(x_115); +x_116 = lean_ctor_get(x_4, 1); +lean_inc(x_116); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_117 = x_4; +} else { + lean_dec_ref(x_4); + x_117 = lean_box(0); +} +x_118 = lean_box(0); +if (lean_is_scalar(x_117)) { + x_119 = lean_alloc_ctor(0, 2, 0); +} else { + x_119 = x_117; +} +lean_ctor_set(x_119, 0, x_118); +lean_ctor_set(x_119, 1, x_116); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_5); +return x_120; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_121 = lean_ctor_get(x_4, 1); +lean_inc(x_121); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_122 = x_4; +} else { + lean_dec_ref(x_4); + x_122 = lean_box(0); +} +x_123 = l_Lake_readTraceFile_x3f___closed__1; +x_124 = lean_string_append(x_123, x_1); +x_125 = l_Lake_readTraceFile_x3f___closed__2; +x_126 = lean_string_append(x_124, x_125); +x_127 = lean_io_error_to_string(x_115); +x_128 = lean_string_append(x_126, x_127); +lean_dec(x_127); +x_129 = lean_string_append(x_128, x_123); +x_130 = 2; +x_131 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_131, 0, x_129); +lean_ctor_set_uint8(x_131, sizeof(void*)*1, x_130); +x_132 = lean_array_push(x_121, x_131); +x_133 = lean_box(0); +if (lean_is_scalar(x_122)) { + x_134 = lean_alloc_ctor(0, 2, 0); +} else { + x_134 = x_122; +} +lean_ctor_set(x_134, 0, x_133); +lean_ctor_set(x_134, 1, x_132); +x_135 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_5); +return x_135; +} +} +else +{ +lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_136 = lean_ctor_get(x_4, 1); +lean_inc(x_136); +if (lean_is_exclusive(x_4)) { + lean_ctor_release(x_4, 0); + lean_ctor_release(x_4, 1); + x_137 = x_4; +} else { + lean_dec_ref(x_4); + x_137 = lean_box(0); +} +x_138 = lean_ctor_get(x_114, 0); +lean_inc(x_138); +lean_dec(x_114); +x_139 = l_Lean_Json_parse(x_138); +if (lean_obj_tag(x_139) == 0) +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_140 = lean_ctor_get(x_139, 0); +lean_inc(x_140); +lean_dec(x_139); +x_141 = l_Lake_readTraceFile_x3f___closed__1; +x_142 = lean_string_append(x_141, x_1); +x_143 = l_Lake_readTraceFile_x3f___closed__3; +x_144 = lean_string_append(x_142, x_143); +x_145 = lean_string_append(x_144, x_140); +lean_dec(x_140); +x_146 = lean_string_append(x_145, x_141); +x_147 = 0; +x_148 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_148, 0, x_146); +lean_ctor_set_uint8(x_148, sizeof(void*)*1, x_147); +x_149 = lean_array_push(x_136, x_148); +x_150 = lean_box(0); +if (lean_is_scalar(x_137)) { + x_151 = lean_alloc_ctor(0, 2, 0); +} else { + x_151 = x_137; +} +lean_ctor_set(x_151, 0, x_150); +lean_ctor_set(x_151, 1, x_149); +x_152 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_152, 0, x_151); +lean_ctor_set(x_152, 1, x_5); +return x_152; +} +else +{ +lean_object* x_153; lean_object* x_154; +x_153 = lean_ctor_get(x_139, 0); +lean_inc(x_153); +lean_dec(x_139); +x_154 = l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79_(x_153); +if (lean_obj_tag(x_154) == 0) +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; uint8_t x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +x_155 = lean_ctor_get(x_154, 0); +lean_inc(x_155); +lean_dec(x_154); +x_156 = l_Lake_readTraceFile_x3f___closed__1; +x_157 = lean_string_append(x_156, x_1); +x_158 = l_Lake_readTraceFile_x3f___closed__3; +x_159 = lean_string_append(x_157, x_158); +x_160 = lean_string_append(x_159, x_155); +lean_dec(x_155); +x_161 = lean_string_append(x_160, x_156); +x_162 = 0; +x_163 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_163, 0, x_161); +lean_ctor_set_uint8(x_163, sizeof(void*)*1, x_162); +x_164 = lean_array_push(x_136, x_163); +x_165 = lean_box(0); +if (lean_is_scalar(x_137)) { + x_166 = lean_alloc_ctor(0, 2, 0); +} else { + x_166 = x_137; +} +lean_ctor_set(x_166, 0, x_165); +lean_ctor_set(x_166, 1, x_164); +x_167 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_167, 0, x_166); +lean_ctor_set(x_167, 1, x_5); +return x_167; +} +else +{ +lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; +x_168 = lean_ctor_get(x_154, 0); +lean_inc(x_168); +lean_dec(x_154); +x_169 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_169, 0, x_168); +if (lean_is_scalar(x_137)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_137; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_136); +x_171 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_171, 0, x_170); +lean_ctor_set(x_171, 1, x_5); +return x_171; +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_readTraceFile_x3f___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_readTraceFile_x3f(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_writeTraceFile(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +lean_inc(x_1); +x_5 = l_Lake_createParentDirs(x_1, x_4); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_ctor_get(x_5, 1); +lean_inc(x_6); +lean_dec(x_5); +x_7 = !lean_is_exclusive(x_2); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_8 = lean_ctor_get(x_2, 1); +lean_dec(x_8); +lean_ctor_set(x_2, 1, x_3); +x_9 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31_(x_2); +x_10 = lean_unsigned_to_nat(80u); +x_11 = l_Lean_Json_pretty(x_9, x_10); +x_12 = l_IO_FS_writeFile(x_1, x_11, x_6); +lean_dec(x_11); +lean_dec(x_1); +return x_12; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_13 = lean_ctor_get(x_2, 0); +lean_inc(x_13); +lean_dec(x_2); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_3); +x_15 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31_(x_14); +x_16 = lean_unsigned_to_nat(80u); +x_17 = l_Lean_Json_pretty(x_15, x_16); +x_18 = l_IO_FS_writeFile(x_1, x_17, x_6); +lean_dec(x_17); +lean_dec(x_1); +return x_18; +} +} +else +{ +uint8_t x_19; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_19 = !lean_is_exclusive(x_5); +if (x_19 == 0) +{ +return x_5; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_5, 0); +x_21 = lean_ctor_get(x_5, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_5); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_4); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_11 = lean_ctor_get(x_4, 0); +x_12 = lean_ctor_get(x_4, 1); +lean_dec(x_12); +x_13 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_13, 0, x_11); +x_14 = l_Lake_instBEqHash; +x_15 = l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____rarg(x_14, x_13, x_5); +x_16 = lean_unbox(x_15); +lean_dec(x_15); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +lean_dec(x_1); +x_17 = lean_ctor_get(x_7, 0); +x_18 = lean_ctor_get_uint8(x_17, sizeof(void*)*1); +if (x_18 == 0) +{ +uint8_t x_19; lean_object* x_20; lean_object* x_21; +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_2); +x_19 = 0; +x_20 = lean_box(x_19); +lean_ctor_set(x_4, 1, x_8); +lean_ctor_set(x_4, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_4); +lean_ctor_set(x_21, 1, x_9); +return x_21; +} +else +{ +uint8_t x_22; +x_22 = !lean_is_exclusive(x_8); +if (x_22 == 0) +{ +lean_object* x_23; uint8_t x_24; +x_23 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_6, x_9); +x_24 = !lean_is_exclusive(x_23); +if (x_24 == 0) +{ +lean_object* x_25; +x_25 = lean_ctor_get(x_23, 0); +lean_ctor_set(x_4, 1, x_8); +lean_ctor_set(x_4, 0, x_25); +lean_ctor_set(x_23, 0, x_4); +return x_23; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_23, 0); +x_27 = lean_ctor_get(x_23, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_23); +lean_ctor_set(x_4, 1, x_8); +lean_ctor_set(x_4, 0, x_26); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_4); +lean_ctor_set(x_28, 1, x_27); +return x_28; +} +} +else +{ +lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_29 = lean_ctor_get(x_8, 0); +x_30 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_29); +lean_dec(x_8); +x_31 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_6, x_9); +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_31, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_34 = x_31; +} else { + lean_dec_ref(x_31); + x_34 = lean_box(0); +} +x_35 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_35, 0, x_29); +lean_ctor_set_uint8(x_35, sizeof(void*)*1, x_30); +lean_ctor_set(x_4, 1, x_35); +lean_ctor_set(x_4, 0, x_32); +if (lean_is_scalar(x_34)) { + x_36 = lean_alloc_ctor(0, 2, 0); +} else { + x_36 = x_34; +} +lean_ctor_set(x_36, 0, x_4); +lean_ctor_set(x_36, 1, x_33); +return x_36; +} +} +} +else +{ +uint8_t x_37; +lean_dec(x_6); +lean_dec(x_2); +x_37 = !lean_is_exclusive(x_8); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +x_38 = lean_ctor_get(x_8, 0); +x_39 = lean_apply_2(x_1, x_3, x_9); +if (lean_obj_tag(x_39) == 0) +{ +uint8_t x_40; +x_40 = !lean_is_exclusive(x_39); +if (x_40 == 0) +{ +lean_object* x_41; +x_41 = lean_ctor_get(x_39, 0); +lean_ctor_set(x_4, 1, x_8); +lean_ctor_set(x_4, 0, x_41); +lean_ctor_set(x_39, 0, x_4); +return x_39; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_39, 0); +x_43 = lean_ctor_get(x_39, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_39); +lean_ctor_set(x_4, 1, x_8); +lean_ctor_set(x_4, 0, x_42); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_4); +lean_ctor_set(x_44, 1, x_43); +return x_44; +} +} +else +{ +uint8_t x_45; +lean_free_object(x_8); +lean_dec(x_38); +lean_free_object(x_4); +x_45 = !lean_is_exclusive(x_39); +if (x_45 == 0) +{ +return x_39; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_39, 0); +x_47 = lean_ctor_get(x_39, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_39); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +return x_48; +} +} +} +else +{ +lean_object* x_49; uint8_t x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_8, 0); +x_50 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_49); +lean_dec(x_8); +x_51 = lean_apply_2(x_1, x_3, x_9); +if (lean_obj_tag(x_51) == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_52 = lean_ctor_get(x_51, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_51, 1); +lean_inc(x_53); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_54 = x_51; +} else { + lean_dec_ref(x_51); + x_54 = lean_box(0); +} +x_55 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_55, 0, x_49); +lean_ctor_set_uint8(x_55, sizeof(void*)*1, x_50); +lean_ctor_set(x_4, 1, x_55); +lean_ctor_set(x_4, 0, x_52); +if (lean_is_scalar(x_54)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_54; +} +lean_ctor_set(x_56, 0, x_4); +lean_ctor_set(x_56, 1, x_53); +return x_56; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_49); +lean_free_object(x_4); +x_57 = lean_ctor_get(x_51, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_51, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_59 = x_51; +} else { + lean_dec_ref(x_51); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; +x_61 = lean_ctor_get(x_4, 0); +lean_inc(x_61); +lean_dec(x_4); +x_62 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_62, 0, x_61); +x_63 = l_Lake_instBEqHash; +x_64 = l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____rarg(x_63, x_62, x_5); +x_65 = lean_unbox(x_64); +lean_dec(x_64); +if (x_65 == 0) +{ +lean_object* x_66; uint8_t x_67; +lean_dec(x_1); +x_66 = lean_ctor_get(x_7, 0); +x_67 = lean_ctor_get_uint8(x_66, sizeof(void*)*1); +if (x_67 == 0) +{ +uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_2); +x_68 = 0; +x_69 = lean_box(x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_8); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_9); +return x_71; +} +else +{ +lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_72 = lean_ctor_get(x_8, 0); +lean_inc(x_72); +x_73 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + x_74 = x_8; +} else { + lean_dec_ref(x_8); + x_74 = lean_box(0); +} +x_75 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_6, x_9); +x_76 = lean_ctor_get(x_75, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_75, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + lean_ctor_release(x_75, 1); + x_78 = x_75; +} else { + lean_dec_ref(x_75); + x_78 = lean_box(0); +} +if (lean_is_scalar(x_74)) { + x_79 = lean_alloc_ctor(0, 1, 1); +} else { + x_79 = x_74; +} +lean_ctor_set(x_79, 0, x_72); +lean_ctor_set_uint8(x_79, sizeof(void*)*1, x_73); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_76); +lean_ctor_set(x_80, 1, x_79); +if (lean_is_scalar(x_78)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_78; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_77); +return x_81; +} +} +else +{ +lean_object* x_82; uint8_t x_83; lean_object* x_84; lean_object* x_85; +lean_dec(x_6); +lean_dec(x_2); +x_82 = lean_ctor_get(x_8, 0); +lean_inc(x_82); +x_83 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + x_84 = x_8; +} else { + lean_dec_ref(x_8); + x_84 = lean_box(0); +} +x_85 = lean_apply_2(x_1, x_3, x_9); +if (lean_obj_tag(x_85) == 0) +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_86 = lean_ctor_get(x_85, 0); +lean_inc(x_86); +x_87 = lean_ctor_get(x_85, 1); +lean_inc(x_87); +if (lean_is_exclusive(x_85)) { + lean_ctor_release(x_85, 0); + lean_ctor_release(x_85, 1); + x_88 = x_85; +} else { + lean_dec_ref(x_85); + x_88 = lean_box(0); +} +if (lean_is_scalar(x_84)) { + x_89 = lean_alloc_ctor(0, 1, 1); +} else { + x_89 = x_84; +} +lean_ctor_set(x_89, 0, x_82); +lean_ctor_set_uint8(x_89, sizeof(void*)*1, x_83); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_86); +lean_ctor_set(x_90, 1, x_89); +if (lean_is_scalar(x_88)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_88; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_87); +return x_91; +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_84); +lean_dec(x_82); +x_92 = lean_ctor_get(x_85, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_85, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_85)) { + lean_ctor_release(x_85, 0); + lean_ctor_release(x_85, 1); + x_94 = x_85; +} else { + lean_dec_ref(x_85); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_checkHashUpToDate___rarg___boxed), 9, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_checkHashUpToDate___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_7); +return x_10; +} +} +static uint8_t _init_l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1() { +_start: +{ +uint32_t x_1; uint8_t x_2; +x_1 = l_Lake_noBuildCode; +x_2 = lean_uint32_to_uint8(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_108; uint8_t x_109; +x_108 = lean_ctor_get(x_6, 0); +lean_inc(x_108); +x_109 = lean_ctor_get_uint8(x_108, sizeof(void*)*1 + 2); +lean_dec(x_108); +if (x_109 == 0) +{ +uint8_t x_110; +x_110 = !lean_is_exclusive(x_7); +if (x_110 == 0) +{ +uint8_t x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; uint8_t x_115; +x_111 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +x_112 = l_Lake_instOrdJobAction; +x_113 = lean_box(x_111); +x_114 = lean_box(x_4); +x_115 = l_instDecidableRelLe___rarg(x_112, x_113, x_114); +if (x_115 == 0) +{ +lean_object* x_116; lean_object* x_117; +x_116 = lean_box(0); +x_117 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_117, 0, x_116); +lean_ctor_set(x_117, 1, x_7); +x_9 = x_117; +x_10 = x_8; +goto block_107; +} +else +{ +lean_object* x_118; lean_object* x_119; +lean_ctor_set_uint8(x_7, sizeof(void*)*1, x_4); +x_118 = lean_box(0); +x_119 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_119, 0, x_118); +lean_ctor_set(x_119, 1, x_7); +x_9 = x_119; +x_10 = x_8; +goto block_107; +} +} +else +{ +lean_object* x_120; uint8_t x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; uint8_t x_125; +x_120 = lean_ctor_get(x_7, 0); +x_121 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_120); +lean_dec(x_7); +x_122 = l_Lake_instOrdJobAction; +x_123 = lean_box(x_121); +x_124 = lean_box(x_4); +x_125 = l_instDecidableRelLe___rarg(x_122, x_123, x_124); +if (x_125 == 0) +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_126, 0, x_120); +lean_ctor_set_uint8(x_126, sizeof(void*)*1, x_121); +x_127 = lean_box(0); +x_128 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_128, 0, x_127); +lean_ctor_set(x_128, 1, x_126); +x_9 = x_128; +x_10 = x_8; +goto block_107; +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; +x_129 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_129, 0, x_120); +lean_ctor_set_uint8(x_129, sizeof(void*)*1, x_4); +x_130 = lean_box(0); +x_131 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_131, 0, x_130); +lean_ctor_set(x_131, 1, x_129); +x_9 = x_131; +x_10 = x_8; +goto block_107; +} +} +} +else +{ +uint8_t x_132; +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_132 = !lean_is_exclusive(x_7); +if (x_132 == 0) +{ +lean_object* x_133; uint8_t x_134; lean_object* x_135; +x_133 = lean_ctor_get(x_7, 0); +x_134 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1; +x_135 = lean_io_exit(x_134, x_8); +if (lean_obj_tag(x_135) == 0) +{ +uint8_t x_136; +x_136 = !lean_is_exclusive(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; +x_137 = lean_ctor_get(x_135, 0); +x_138 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_138, 0, x_137); +lean_ctor_set(x_138, 1, x_7); +lean_ctor_set(x_135, 0, x_138); +return x_135; +} +else +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; +x_139 = lean_ctor_get(x_135, 0); +x_140 = lean_ctor_get(x_135, 1); +lean_inc(x_140); +lean_inc(x_139); +lean_dec(x_135); +x_141 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_141, 0, x_139); +lean_ctor_set(x_141, 1, x_7); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_140); +return x_142; +} +} +else +{ +uint8_t x_143; +x_143 = !lean_is_exclusive(x_135); +if (x_143 == 0) +{ +lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_144 = lean_ctor_get(x_135, 0); +x_145 = lean_io_error_to_string(x_144); +x_146 = 3; +x_147 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set_uint8(x_147, sizeof(void*)*1, x_146); +x_148 = lean_array_get_size(x_133); +x_149 = lean_array_push(x_133, x_147); +lean_ctor_set(x_7, 0, x_149); +x_150 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_150, 0, x_148); +lean_ctor_set(x_150, 1, x_7); +lean_ctor_set_tag(x_135, 0); +lean_ctor_set(x_135, 0, x_150); +return x_135; +} +else +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; +x_151 = lean_ctor_get(x_135, 0); +x_152 = lean_ctor_get(x_135, 1); +lean_inc(x_152); +lean_inc(x_151); +lean_dec(x_135); +x_153 = lean_io_error_to_string(x_151); +x_154 = 3; +x_155 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_155, 0, x_153); +lean_ctor_set_uint8(x_155, sizeof(void*)*1, x_154); +x_156 = lean_array_get_size(x_133); +x_157 = lean_array_push(x_133, x_155); +lean_ctor_set(x_7, 0, x_157); +x_158 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_158, 0, x_156); +lean_ctor_set(x_158, 1, x_7); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_152); +return x_159; +} +} +} +else +{ +lean_object* x_160; uint8_t x_161; uint8_t x_162; lean_object* x_163; +x_160 = lean_ctor_get(x_7, 0); +x_161 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_160); +lean_dec(x_7); +x_162 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1; +x_163 = lean_io_exit(x_162, x_8); +if (lean_obj_tag(x_163) == 0) +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +x_164 = lean_ctor_get(x_163, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_163, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_163)) { + lean_ctor_release(x_163, 0); + lean_ctor_release(x_163, 1); + x_166 = x_163; +} else { + lean_dec_ref(x_163); + x_166 = lean_box(0); +} +x_167 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_167, 0, x_160); +lean_ctor_set_uint8(x_167, sizeof(void*)*1, x_161); +x_168 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_168, 0, x_164); +lean_ctor_set(x_168, 1, x_167); +if (lean_is_scalar(x_166)) { + x_169 = lean_alloc_ctor(0, 2, 0); +} else { + x_169 = x_166; +} +lean_ctor_set(x_169, 0, x_168); +lean_ctor_set(x_169, 1, x_165); +return x_169; +} +else +{ +lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_170 = lean_ctor_get(x_163, 0); +lean_inc(x_170); +x_171 = lean_ctor_get(x_163, 1); +lean_inc(x_171); +if (lean_is_exclusive(x_163)) { + lean_ctor_release(x_163, 0); + lean_ctor_release(x_163, 1); + x_172 = x_163; +} else { + lean_dec_ref(x_163); + x_172 = lean_box(0); +} +x_173 = lean_io_error_to_string(x_170); +x_174 = 3; +x_175 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_175, 0, x_173); +lean_ctor_set_uint8(x_175, sizeof(void*)*1, x_174); +x_176 = lean_array_get_size(x_160); +x_177 = lean_array_push(x_160, x_175); +x_178 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set_uint8(x_178, sizeof(void*)*1, x_161); +x_179 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_179, 0, x_176); +lean_ctor_set(x_179, 1, x_178); +if (lean_is_scalar(x_172)) { + x_180 = lean_alloc_ctor(0, 2, 0); +} else { + x_180 = x_172; + lean_ctor_set_tag(x_180, 0); +} +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_171); +return x_180; +} +} +} +block_107: +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_array_get_size(x_12); +lean_dec(x_12); +x_14 = lean_apply_3(x_1, x_6, x_11, x_10); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_15); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_17 = lean_ctor_get(x_15, 1); +x_18 = lean_ctor_get(x_15, 0); +lean_dec(x_18); +x_19 = lean_ctor_get(x_14, 1); +lean_inc(x_19); +lean_dec(x_14); +x_20 = !lean_is_exclusive(x_17); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_17, 0); +x_22 = lean_array_get_size(x_21); +x_23 = l_Array_extract___rarg(x_21, x_13, x_22); +x_24 = l_Lake_writeTraceFile(x_2, x_3, x_23, x_19); +if (lean_obj_tag(x_24) == 0) +{ +uint8_t x_25; +lean_dec(x_22); +x_25 = !lean_is_exclusive(x_24); +if (x_25 == 0) +{ +lean_object* x_26; uint8_t x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_24, 0); +lean_dec(x_26); +x_27 = 0; +x_28 = lean_box(x_27); +lean_ctor_set(x_15, 0, x_28); +lean_ctor_set(x_24, 0, x_15); +return x_24; +} +else +{ +lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; +x_29 = lean_ctor_get(x_24, 1); +lean_inc(x_29); +lean_dec(x_24); +x_30 = 0; +x_31 = lean_box(x_30); +lean_ctor_set(x_15, 0, x_31); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_15); +lean_ctor_set(x_32, 1, x_29); +return x_32; +} +} +else +{ +uint8_t x_33; +x_33 = !lean_is_exclusive(x_24); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_24, 0); +x_35 = lean_io_error_to_string(x_34); +x_36 = 3; +x_37 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set_uint8(x_37, sizeof(void*)*1, x_36); +x_38 = lean_array_push(x_21, x_37); +lean_ctor_set(x_17, 0, x_38); +lean_ctor_set_tag(x_15, 1); +lean_ctor_set(x_15, 0, x_22); +lean_ctor_set_tag(x_24, 0); +lean_ctor_set(x_24, 0, x_15); +return x_24; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_39 = lean_ctor_get(x_24, 0); +x_40 = lean_ctor_get(x_24, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_24); +x_41 = lean_io_error_to_string(x_39); +x_42 = 3; +x_43 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set_uint8(x_43, sizeof(void*)*1, x_42); +x_44 = lean_array_push(x_21, x_43); +lean_ctor_set(x_17, 0, x_44); +lean_ctor_set_tag(x_15, 1); +lean_ctor_set(x_15, 0, x_22); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_15); +lean_ctor_set(x_45, 1, x_40); +return x_45; +} +} +} +else +{ +lean_object* x_46; uint8_t x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_46 = lean_ctor_get(x_17, 0); +x_47 = lean_ctor_get_uint8(x_17, sizeof(void*)*1); +lean_inc(x_46); +lean_dec(x_17); +x_48 = lean_array_get_size(x_46); +x_49 = l_Array_extract___rarg(x_46, x_13, x_48); +x_50 = l_Lake_writeTraceFile(x_2, x_3, x_49, x_19); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; +lean_dec(x_48); +x_51 = lean_ctor_get(x_50, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_52 = x_50; +} else { + lean_dec_ref(x_50); + x_52 = lean_box(0); +} +x_53 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_53, 0, x_46); +lean_ctor_set_uint8(x_53, sizeof(void*)*1, x_47); +x_54 = 0; +x_55 = lean_box(x_54); +lean_ctor_set(x_15, 1, x_53); +lean_ctor_set(x_15, 0, x_55); +if (lean_is_scalar(x_52)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_52; +} +lean_ctor_set(x_56, 0, x_15); +lean_ctor_set(x_56, 1, x_51); +return x_56; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_57 = lean_ctor_get(x_50, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_50, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_59 = x_50; +} else { + lean_dec_ref(x_50); + x_59 = lean_box(0); +} +x_60 = lean_io_error_to_string(x_57); +x_61 = 3; +x_62 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set_uint8(x_62, sizeof(void*)*1, x_61); +x_63 = lean_array_push(x_46, x_62); +x_64 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set_uint8(x_64, sizeof(void*)*1, x_47); +lean_ctor_set_tag(x_15, 1); +lean_ctor_set(x_15, 1, x_64); +lean_ctor_set(x_15, 0, x_48); +if (lean_is_scalar(x_59)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_59; + lean_ctor_set_tag(x_65, 0); +} +lean_ctor_set(x_65, 0, x_15); +lean_ctor_set(x_65, 1, x_58); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_66 = lean_ctor_get(x_15, 1); +lean_inc(x_66); +lean_dec(x_15); +x_67 = lean_ctor_get(x_14, 1); +lean_inc(x_67); +lean_dec(x_14); +x_68 = lean_ctor_get(x_66, 0); +lean_inc(x_68); +x_69 = lean_ctor_get_uint8(x_66, sizeof(void*)*1); +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + x_70 = x_66; +} else { + lean_dec_ref(x_66); + x_70 = lean_box(0); +} +x_71 = lean_array_get_size(x_68); +x_72 = l_Array_extract___rarg(x_68, x_13, x_71); +x_73 = l_Lake_writeTraceFile(x_2, x_3, x_72, x_67); +if (lean_obj_tag(x_73) == 0) +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +lean_dec(x_71); +x_74 = lean_ctor_get(x_73, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_73)) { + lean_ctor_release(x_73, 0); + lean_ctor_release(x_73, 1); + x_75 = x_73; +} else { + lean_dec_ref(x_73); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_76 = lean_alloc_ctor(0, 1, 1); +} else { + x_76 = x_70; +} +lean_ctor_set(x_76, 0, x_68); +lean_ctor_set_uint8(x_76, sizeof(void*)*1, x_69); +x_77 = 0; +x_78 = lean_box(x_77); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_76); +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 2, 0); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_74); +return x_80; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_81 = lean_ctor_get(x_73, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_73, 1); +lean_inc(x_82); +if (lean_is_exclusive(x_73)) { + lean_ctor_release(x_73, 0); + lean_ctor_release(x_73, 1); + x_83 = x_73; +} else { + lean_dec_ref(x_73); + x_83 = lean_box(0); +} +x_84 = lean_io_error_to_string(x_81); +x_85 = 3; +x_86 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_86, 0, x_84); +lean_ctor_set_uint8(x_86, sizeof(void*)*1, x_85); +x_87 = lean_array_push(x_68, x_86); +if (lean_is_scalar(x_70)) { + x_88 = lean_alloc_ctor(0, 1, 1); +} else { + x_88 = x_70; +} +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set_uint8(x_88, sizeof(void*)*1, x_69); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_71); +lean_ctor_set(x_89, 1, x_88); +if (lean_is_scalar(x_83)) { + x_90 = lean_alloc_ctor(0, 2, 0); +} else { + x_90 = x_83; + lean_ctor_set_tag(x_90, 0); +} +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_82); +return x_90; +} +} +} +else +{ +uint8_t x_91; +lean_dec(x_13); +lean_dec(x_3); +lean_dec(x_2); +x_91 = !lean_is_exclusive(x_14); +if (x_91 == 0) +{ +lean_object* x_92; uint8_t x_93; +x_92 = lean_ctor_get(x_14, 0); +lean_dec(x_92); +x_93 = !lean_is_exclusive(x_15); +if (x_93 == 0) +{ +return x_14; +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_94 = lean_ctor_get(x_15, 0); +x_95 = lean_ctor_get(x_15, 1); +lean_inc(x_95); +lean_inc(x_94); +lean_dec(x_15); +x_96 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_96, 0, x_94); +lean_ctor_set(x_96, 1, x_95); +lean_ctor_set(x_14, 0, x_96); +return x_14; +} +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; +x_97 = lean_ctor_get(x_14, 1); +lean_inc(x_97); +lean_dec(x_14); +x_98 = lean_ctor_get(x_15, 0); +lean_inc(x_98); +x_99 = lean_ctor_get(x_15, 1); +lean_inc(x_99); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_100 = x_15; +} else { + lean_dec_ref(x_15); + x_100 = lean_box(0); +} +if (lean_is_scalar(x_100)) { + x_101 = lean_alloc_ctor(1, 2, 0); +} else { + x_101 = x_100; +} +lean_ctor_set(x_101, 0, x_98); +lean_ctor_set(x_101, 1, x_99); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_97); +return x_102; +} +} +} +else +{ +uint8_t x_103; +lean_dec(x_13); +lean_dec(x_3); +lean_dec(x_2); +x_103 = !lean_is_exclusive(x_14); +if (x_103 == 0) +{ +return x_14; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_14, 0); +x_105 = lean_ctor_get(x_14, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_14); +x_106 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_106, 0, x_104); +lean_ctor_set(x_106, 1, x_105); +return x_106; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_7 = lean_ctor_get(x_4, 0); +x_8 = lean_array_push(x_7, x_2); +lean_ctor_set(x_4, 0, x_8); +x_9 = lean_box(0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_5); +return x_11; +} +else +{ +lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_12 = lean_ctor_get(x_4, 0); +x_13 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_12); +lean_dec(x_4); +x_14 = lean_array_push(x_12, x_2); +x_15 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set_uint8(x_15, sizeof(void*)*1, x_13); +x_16 = lean_box(0); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_5); +return x_18; +} +} +} +static lean_object* _init_l_Lake_buildUnlessUpToDate_x3f___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_instMonadBaseIO; +x_2 = l_Lake_EStateT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__1; +x_2 = l_ReaderT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__2___boxed), 5, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, uint8_t x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; uint8_t x_416; +x_416 = !lean_is_exclusive(x_10); +if (x_416 == 0) +{ +lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; +x_417 = lean_ctor_get(x_10, 0); +x_418 = l_Lake_readTraceFile_x3f(x_5, x_417, x_11); +x_419 = lean_ctor_get(x_418, 0); +lean_inc(x_419); +x_420 = lean_ctor_get(x_418, 1); +lean_inc(x_420); +lean_dec(x_418); +x_421 = !lean_is_exclusive(x_419); +if (x_421 == 0) +{ +lean_object* x_422; +x_422 = lean_ctor_get(x_419, 1); +lean_ctor_set(x_10, 0, x_422); +lean_ctor_set(x_419, 1, x_10); +x_12 = x_419; +x_13 = x_420; +goto block_415; +} +else +{ +lean_object* x_423; lean_object* x_424; lean_object* x_425; +x_423 = lean_ctor_get(x_419, 0); +x_424 = lean_ctor_get(x_419, 1); +lean_inc(x_424); +lean_inc(x_423); +lean_dec(x_419); +lean_ctor_set(x_10, 0, x_424); +x_425 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_425, 0, x_423); +lean_ctor_set(x_425, 1, x_10); +x_12 = x_425; +x_13 = x_420; +goto block_415; +} +} +else +{ +lean_object* x_426; uint8_t x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; +x_426 = lean_ctor_get(x_10, 0); +x_427 = lean_ctor_get_uint8(x_10, sizeof(void*)*1); +lean_inc(x_426); +lean_dec(x_10); +x_428 = l_Lake_readTraceFile_x3f(x_5, x_426, x_11); +x_429 = lean_ctor_get(x_428, 0); +lean_inc(x_429); +x_430 = lean_ctor_get(x_428, 1); +lean_inc(x_430); +lean_dec(x_428); +x_431 = lean_ctor_get(x_429, 0); +lean_inc(x_431); +x_432 = lean_ctor_get(x_429, 1); +lean_inc(x_432); +if (lean_is_exclusive(x_429)) { + lean_ctor_release(x_429, 0); + lean_ctor_release(x_429, 1); + x_433 = x_429; +} else { + lean_dec_ref(x_429); + x_433 = lean_box(0); +} +x_434 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_434, 0, x_432); +lean_ctor_set_uint8(x_434, sizeof(void*)*1, x_427); +if (lean_is_scalar(x_433)) { + x_435 = lean_alloc_ctor(0, 2, 0); +} else { + x_435 = x_433; +} +lean_ctor_set(x_435, 0, x_431); +lean_ctor_set(x_435, 1, x_434); +x_12 = x_435; +x_13 = x_430; +goto block_415; +} +block_415: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; uint8_t x_16; +lean_dec(x_1); +x_15 = lean_ctor_get(x_9, 0); +lean_inc(x_15); +x_16 = lean_ctor_get_uint8(x_15, sizeof(void*)*1); +lean_dec(x_15); +if (x_16 == 0) +{ +uint8_t x_17; +lean_dec(x_8); +x_17 = !lean_is_exclusive(x_12); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_18 = lean_ctor_get(x_12, 1); +x_19 = lean_ctor_get(x_12, 0); +lean_dec(x_19); +x_20 = !lean_is_exclusive(x_18); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; uint8_t x_23; +x_21 = lean_ctor_get(x_4, 1); +lean_inc(x_21); +x_22 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_21, x_13); +x_23 = !lean_is_exclusive(x_22); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; uint8_t x_26; +x_24 = lean_ctor_get(x_22, 0); +x_25 = lean_ctor_get(x_22, 1); +x_26 = lean_unbox(x_24); +lean_dec(x_24); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; +lean_free_object(x_22); +lean_free_object(x_12); +x_27 = lean_box(0); +x_28 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_27, x_9, x_18, x_25); +return x_28; +} +else +{ +uint8_t x_29; lean_object* x_30; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_29 = 1; +x_30 = lean_box(x_29); +lean_ctor_set(x_12, 0, x_30); +lean_ctor_set(x_22, 0, x_12); +return x_22; +} +} +else +{ +lean_object* x_31; lean_object* x_32; uint8_t x_33; +x_31 = lean_ctor_get(x_22, 0); +x_32 = lean_ctor_get(x_22, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_22); +x_33 = lean_unbox(x_31); +lean_dec(x_31); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; +lean_free_object(x_12); +x_34 = lean_box(0); +x_35 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_34, x_9, x_18, x_32); +return x_35; +} +else +{ +uint8_t x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_36 = 1; +x_37 = lean_box(x_36); +lean_ctor_set(x_12, 0, x_37); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_12); +lean_ctor_set(x_38, 1, x_32); +return x_38; +} +} +} +else +{ +lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; +x_39 = lean_ctor_get(x_18, 0); +x_40 = lean_ctor_get_uint8(x_18, sizeof(void*)*1); +lean_inc(x_39); +lean_dec(x_18); +x_41 = lean_ctor_get(x_4, 1); +lean_inc(x_41); +x_42 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_41, x_13); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_39); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_40); +x_47 = lean_unbox(x_43); +lean_dec(x_43); +if (x_47 == 0) +{ +lean_object* x_48; lean_object* x_49; +lean_dec(x_45); +lean_free_object(x_12); +x_48 = lean_box(0); +x_49 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_48, x_9, x_46, x_44); +return x_49; +} +else +{ +uint8_t x_50; lean_object* x_51; lean_object* x_52; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_50 = 1; +x_51 = lean_box(x_50); +lean_ctor_set(x_12, 1, x_46); +lean_ctor_set(x_12, 0, x_51); +if (lean_is_scalar(x_45)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_45; +} +lean_ctor_set(x_52, 0, x_12); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; +x_53 = lean_ctor_get(x_12, 1); +lean_inc(x_53); +lean_dec(x_12); +x_54 = lean_ctor_get(x_53, 0); +lean_inc(x_54); +x_55 = lean_ctor_get_uint8(x_53, sizeof(void*)*1); +if (lean_is_exclusive(x_53)) { + lean_ctor_release(x_53, 0); + x_56 = x_53; +} else { + lean_dec_ref(x_53); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_4, 1); +lean_inc(x_57); +x_58 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_57, x_13); +x_59 = lean_ctor_get(x_58, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_58, 1); +lean_inc(x_60); +if (lean_is_exclusive(x_58)) { + lean_ctor_release(x_58, 0); + lean_ctor_release(x_58, 1); + x_61 = x_58; +} else { + lean_dec_ref(x_58); + x_61 = lean_box(0); +} +if (lean_is_scalar(x_56)) { + x_62 = lean_alloc_ctor(0, 1, 1); +} else { + x_62 = x_56; +} +lean_ctor_set(x_62, 0, x_54); +lean_ctor_set_uint8(x_62, sizeof(void*)*1, x_55); +x_63 = lean_unbox(x_59); +lean_dec(x_59); +if (x_63 == 0) +{ +lean_object* x_64; lean_object* x_65; +lean_dec(x_61); +x_64 = lean_box(0); +x_65 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_64, x_9, x_62, x_60); +return x_65; +} +else +{ +uint8_t x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_66 = 1; +x_67 = lean_box(x_66); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_67); +lean_ctor_set(x_68, 1, x_62); +if (lean_is_scalar(x_61)) { + x_69 = lean_alloc_ctor(0, 2, 0); +} else { + x_69 = x_61; +} +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_60); +return x_69; +} +} +} +else +{ +uint8_t x_70; +x_70 = !lean_is_exclusive(x_12); +if (x_70 == 0) +{ +lean_object* x_71; lean_object* x_72; uint8_t x_73; +x_71 = lean_ctor_get(x_12, 1); +x_72 = lean_ctor_get(x_12, 0); +lean_dec(x_72); +x_73 = !lean_is_exclusive(x_71); +if (x_73 == 0) +{ +lean_object* x_74; uint8_t x_75; +x_74 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_8, x_13); +x_75 = !lean_is_exclusive(x_74); +if (x_75 == 0) +{ +lean_object* x_76; lean_object* x_77; uint8_t x_78; +x_76 = lean_ctor_get(x_74, 0); +x_77 = lean_ctor_get(x_74, 1); +x_78 = lean_unbox(x_76); +lean_dec(x_76); +if (x_78 == 0) +{ +lean_object* x_79; lean_object* x_80; +lean_free_object(x_74); +lean_free_object(x_12); +x_79 = lean_box(0); +x_80 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_79, x_9, x_71, x_77); +return x_80; +} +else +{ +uint8_t x_81; lean_object* x_82; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_81 = 1; +x_82 = lean_box(x_81); +lean_ctor_set(x_12, 0, x_82); +lean_ctor_set(x_74, 0, x_12); +return x_74; +} +} +else +{ +lean_object* x_83; lean_object* x_84; uint8_t x_85; +x_83 = lean_ctor_get(x_74, 0); +x_84 = lean_ctor_get(x_74, 1); +lean_inc(x_84); +lean_inc(x_83); +lean_dec(x_74); +x_85 = lean_unbox(x_83); +lean_dec(x_83); +if (x_85 == 0) +{ +lean_object* x_86; lean_object* x_87; +lean_free_object(x_12); +x_86 = lean_box(0); +x_87 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_86, x_9, x_71, x_84); +return x_87; +} +else +{ +uint8_t x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_88 = 1; +x_89 = lean_box(x_88); +lean_ctor_set(x_12, 0, x_89); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_12); +lean_ctor_set(x_90, 1, x_84); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; +x_91 = lean_ctor_get(x_71, 0); +x_92 = lean_ctor_get_uint8(x_71, sizeof(void*)*1); +lean_inc(x_91); +lean_dec(x_71); +x_93 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_8, x_13); +x_94 = lean_ctor_get(x_93, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_93, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_93)) { + lean_ctor_release(x_93, 0); + lean_ctor_release(x_93, 1); + x_96 = x_93; +} else { + lean_dec_ref(x_93); + x_96 = lean_box(0); +} +x_97 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_97, 0, x_91); +lean_ctor_set_uint8(x_97, sizeof(void*)*1, x_92); +x_98 = lean_unbox(x_94); +lean_dec(x_94); +if (x_98 == 0) +{ +lean_object* x_99; lean_object* x_100; +lean_dec(x_96); +lean_free_object(x_12); +x_99 = lean_box(0); +x_100 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_99, x_9, x_97, x_95); +return x_100; +} +else +{ +uint8_t x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_101 = 1; +x_102 = lean_box(x_101); +lean_ctor_set(x_12, 1, x_97); +lean_ctor_set(x_12, 0, x_102); +if (lean_is_scalar(x_96)) { + x_103 = lean_alloc_ctor(0, 2, 0); +} else { + x_103 = x_96; +} +lean_ctor_set(x_103, 0, x_12); +lean_ctor_set(x_103, 1, x_95); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; +x_104 = lean_ctor_get(x_12, 1); +lean_inc(x_104); +lean_dec(x_12); +x_105 = lean_ctor_get(x_104, 0); +lean_inc(x_105); +x_106 = lean_ctor_get_uint8(x_104, sizeof(void*)*1); +if (lean_is_exclusive(x_104)) { + lean_ctor_release(x_104, 0); + x_107 = x_104; +} else { + lean_dec_ref(x_104); + x_107 = lean_box(0); +} +x_108 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_8, x_13); +x_109 = lean_ctor_get(x_108, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_108, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_108)) { + lean_ctor_release(x_108, 0); + lean_ctor_release(x_108, 1); + x_111 = x_108; +} else { + lean_dec_ref(x_108); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_112 = lean_alloc_ctor(0, 1, 1); +} else { + x_112 = x_107; +} +lean_ctor_set(x_112, 0, x_105); +lean_ctor_set_uint8(x_112, sizeof(void*)*1, x_106); +x_113 = lean_unbox(x_109); +lean_dec(x_109); +if (x_113 == 0) +{ +lean_object* x_114; lean_object* x_115; +lean_dec(x_111); +x_114 = lean_box(0); +x_115 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_114, x_9, x_112, x_110); +return x_115; +} +else +{ +uint8_t x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_116 = 1; +x_117 = lean_box(x_116); +x_118 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_112); +if (lean_is_scalar(x_111)) { + x_119 = lean_alloc_ctor(0, 2, 0); +} else { + x_119 = x_111; +} +lean_ctor_set(x_119, 0, x_118); +lean_ctor_set(x_119, 1, x_110); +return x_119; +} +} +} +} +else +{ +uint8_t x_120; +x_120 = !lean_is_exclusive(x_14); +if (x_120 == 0) +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; +x_121 = lean_ctor_get(x_14, 0); +x_122 = lean_ctor_get(x_12, 1); +lean_inc(x_122); +lean_dec(x_12); +x_123 = lean_ctor_get(x_121, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_121, 1); +lean_inc(x_124); +lean_dec(x_121); +lean_ctor_set(x_14, 0, x_123); +lean_inc(x_4); +x_125 = l_Lake_checkHashUpToDate___rarg(x_1, x_2, x_3, x_4, x_14, x_8, x_9, x_122, x_13); +if (lean_obj_tag(x_125) == 0) +{ +lean_object* x_126; +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +if (lean_obj_tag(x_126) == 0) +{ +lean_object* x_127; lean_object* x_128; uint8_t x_129; +x_127 = lean_ctor_get(x_125, 1); +lean_inc(x_127); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + lean_ctor_release(x_125, 1); + x_128 = x_125; +} else { + lean_dec_ref(x_125); + x_128 = lean_box(0); +} +x_129 = !lean_is_exclusive(x_126); +if (x_129 == 0) +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_229; +x_130 = lean_ctor_get(x_126, 0); +x_131 = lean_ctor_get(x_126, 1); +x_229 = lean_unbox(x_130); +lean_dec(x_130); +if (x_229 == 0) +{ +lean_object* x_230; lean_object* x_231; +lean_free_object(x_126); +lean_dec(x_128); +lean_dec(x_124); +x_230 = lean_box(0); +x_231 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_230, x_9, x_131, x_127); +return x_231; +} +else +{ +uint8_t x_232; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_232 = !lean_is_exclusive(x_131); +if (x_232 == 0) +{ +uint8_t x_233; lean_object* x_234; uint8_t x_235; lean_object* x_236; lean_object* x_237; uint8_t x_238; +x_233 = lean_ctor_get_uint8(x_131, sizeof(void*)*1); +x_234 = l_Lake_instOrdJobAction; +x_235 = 1; +x_236 = lean_box(x_233); +x_237 = lean_box(x_235); +x_238 = l_instDecidableRelLe___rarg(x_234, x_236, x_237); +if (x_238 == 0) +{ +lean_object* x_239; +x_239 = lean_box(0); +lean_ctor_set(x_126, 0, x_239); +x_132 = x_126; +x_133 = x_127; +goto block_228; +} +else +{ +lean_object* x_240; +lean_ctor_set_uint8(x_131, sizeof(void*)*1, x_235); +x_240 = lean_box(0); +lean_ctor_set(x_126, 0, x_240); +x_132 = x_126; +x_133 = x_127; +goto block_228; +} +} +else +{ +lean_object* x_241; uint8_t x_242; lean_object* x_243; uint8_t x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; +x_241 = lean_ctor_get(x_131, 0); +x_242 = lean_ctor_get_uint8(x_131, sizeof(void*)*1); +lean_inc(x_241); +lean_dec(x_131); +x_243 = l_Lake_instOrdJobAction; +x_244 = 1; +x_245 = lean_box(x_242); +x_246 = lean_box(x_244); +x_247 = l_instDecidableRelLe___rarg(x_243, x_245, x_246); +if (x_247 == 0) +{ +lean_object* x_248; lean_object* x_249; +x_248 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_248, 0, x_241); +lean_ctor_set_uint8(x_248, sizeof(void*)*1, x_242); +x_249 = lean_box(0); +lean_ctor_set(x_126, 1, x_248); +lean_ctor_set(x_126, 0, x_249); +x_132 = x_126; +x_133 = x_127; +goto block_228; +} +else +{ +lean_object* x_250; lean_object* x_251; +x_250 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_250, 0, x_241); +lean_ctor_set_uint8(x_250, sizeof(void*)*1, x_244); +x_251 = lean_box(0); +lean_ctor_set(x_126, 1, x_250); +lean_ctor_set(x_126, 0, x_251); +x_132 = x_126; +x_133 = x_127; +goto block_228; +} +} +} +block_228: +{ +uint8_t x_134; +x_134 = !lean_is_exclusive(x_132); +if (x_134 == 0) +{ +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; +x_135 = lean_ctor_get(x_132, 1); +x_136 = lean_ctor_get(x_132, 0); +lean_dec(x_136); +x_137 = lean_array_get_size(x_124); +x_138 = lean_unsigned_to_nat(0u); +x_139 = lean_nat_dec_lt(x_138, x_137); +if (x_139 == 0) +{ +uint8_t x_140; lean_object* x_141; lean_object* x_142; +lean_dec(x_137); +lean_dec(x_124); +lean_dec(x_9); +x_140 = 1; +x_141 = lean_box(x_140); +lean_ctor_set(x_132, 0, x_141); +if (lean_is_scalar(x_128)) { + x_142 = lean_alloc_ctor(0, 2, 0); +} else { + x_142 = x_128; +} +lean_ctor_set(x_142, 0, x_132); +lean_ctor_set(x_142, 1, x_133); +return x_142; +} +else +{ +uint8_t x_143; +x_143 = lean_nat_dec_le(x_137, x_137); +if (x_143 == 0) +{ +uint8_t x_144; lean_object* x_145; lean_object* x_146; +lean_dec(x_137); +lean_dec(x_124); +lean_dec(x_9); +x_144 = 1; +x_145 = lean_box(x_144); +lean_ctor_set(x_132, 0, x_145); +if (lean_is_scalar(x_128)) { + x_146 = lean_alloc_ctor(0, 2, 0); +} else { + x_146 = x_128; +} +lean_ctor_set(x_146, 0, x_132); +lean_ctor_set(x_146, 1, x_133); +return x_146; +} +else +{ +size_t x_147; size_t x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; +lean_free_object(x_132); +lean_dec(x_128); +x_147 = 0; +x_148 = lean_usize_of_nat(x_137); +lean_dec(x_137); +x_149 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2; +x_150 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3; +x_151 = lean_box(0); +x_152 = l_Array_foldlMUnsafe_fold___rarg(x_149, x_150, x_124, x_147, x_148, x_151); +x_153 = lean_apply_3(x_152, x_9, x_135, x_133); +if (lean_obj_tag(x_153) == 0) +{ +lean_object* x_154; +x_154 = lean_ctor_get(x_153, 0); +lean_inc(x_154); +if (lean_obj_tag(x_154) == 0) +{ +uint8_t x_155; +x_155 = !lean_is_exclusive(x_153); +if (x_155 == 0) +{ +lean_object* x_156; uint8_t x_157; +x_156 = lean_ctor_get(x_153, 0); +lean_dec(x_156); +x_157 = !lean_is_exclusive(x_154); +if (x_157 == 0) +{ +lean_object* x_158; uint8_t x_159; lean_object* x_160; +x_158 = lean_ctor_get(x_154, 0); +lean_dec(x_158); +x_159 = 1; +x_160 = lean_box(x_159); +lean_ctor_set(x_154, 0, x_160); +return x_153; +} +else +{ +lean_object* x_161; uint8_t x_162; lean_object* x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_154, 1); +lean_inc(x_161); +lean_dec(x_154); +x_162 = 1; +x_163 = lean_box(x_162); +x_164 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_164, 0, x_163); +lean_ctor_set(x_164, 1, x_161); +lean_ctor_set(x_153, 0, x_164); +return x_153; +} +} +else +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; uint8_t x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; +x_165 = lean_ctor_get(x_153, 1); +lean_inc(x_165); +lean_dec(x_153); +x_166 = lean_ctor_get(x_154, 1); +lean_inc(x_166); +if (lean_is_exclusive(x_154)) { + lean_ctor_release(x_154, 0); + lean_ctor_release(x_154, 1); + x_167 = x_154; +} else { + lean_dec_ref(x_154); + x_167 = lean_box(0); +} +x_168 = 1; +x_169 = lean_box(x_168); +if (lean_is_scalar(x_167)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_167; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_166); +x_171 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_171, 0, x_170); +lean_ctor_set(x_171, 1, x_165); +return x_171; +} +} +else +{ +uint8_t x_172; +x_172 = !lean_is_exclusive(x_153); +if (x_172 == 0) +{ +lean_object* x_173; uint8_t x_174; +x_173 = lean_ctor_get(x_153, 0); +lean_dec(x_173); +x_174 = !lean_is_exclusive(x_154); +if (x_174 == 0) +{ +return x_153; +} +else +{ +lean_object* x_175; lean_object* x_176; lean_object* x_177; +x_175 = lean_ctor_get(x_154, 0); +x_176 = lean_ctor_get(x_154, 1); +lean_inc(x_176); +lean_inc(x_175); +lean_dec(x_154); +x_177 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_177, 0, x_175); +lean_ctor_set(x_177, 1, x_176); +lean_ctor_set(x_153, 0, x_177); +return x_153; +} +} +else +{ +lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_178 = lean_ctor_get(x_153, 1); +lean_inc(x_178); +lean_dec(x_153); +x_179 = lean_ctor_get(x_154, 0); +lean_inc(x_179); +x_180 = lean_ctor_get(x_154, 1); +lean_inc(x_180); +if (lean_is_exclusive(x_154)) { + lean_ctor_release(x_154, 0); + lean_ctor_release(x_154, 1); + x_181 = x_154; +} else { + lean_dec_ref(x_154); + x_181 = lean_box(0); +} +if (lean_is_scalar(x_181)) { + x_182 = lean_alloc_ctor(1, 2, 0); +} else { + x_182 = x_181; +} +lean_ctor_set(x_182, 0, x_179); +lean_ctor_set(x_182, 1, x_180); +x_183 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_178); +return x_183; +} +} +} +else +{ +uint8_t x_184; +x_184 = !lean_is_exclusive(x_153); +if (x_184 == 0) +{ +return x_153; +} +else +{ +lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_185 = lean_ctor_get(x_153, 0); +x_186 = lean_ctor_get(x_153, 1); +lean_inc(x_186); +lean_inc(x_185); +lean_dec(x_153); +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; +} +} +} +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_191; +x_188 = lean_ctor_get(x_132, 1); +lean_inc(x_188); +lean_dec(x_132); +x_189 = lean_array_get_size(x_124); +x_190 = lean_unsigned_to_nat(0u); +x_191 = lean_nat_dec_lt(x_190, x_189); +if (x_191 == 0) +{ +uint8_t x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; +lean_dec(x_189); +lean_dec(x_124); +lean_dec(x_9); +x_192 = 1; +x_193 = lean_box(x_192); +x_194 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_194, 0, x_193); +lean_ctor_set(x_194, 1, x_188); +if (lean_is_scalar(x_128)) { + x_195 = lean_alloc_ctor(0, 2, 0); +} else { + x_195 = x_128; +} +lean_ctor_set(x_195, 0, x_194); +lean_ctor_set(x_195, 1, x_133); +return x_195; +} +else +{ +uint8_t x_196; +x_196 = lean_nat_dec_le(x_189, x_189); +if (x_196 == 0) +{ +uint8_t x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +lean_dec(x_189); +lean_dec(x_124); +lean_dec(x_9); +x_197 = 1; +x_198 = lean_box(x_197); +x_199 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_199, 0, x_198); +lean_ctor_set(x_199, 1, x_188); +if (lean_is_scalar(x_128)) { + x_200 = lean_alloc_ctor(0, 2, 0); +} else { + x_200 = x_128; +} +lean_ctor_set(x_200, 0, x_199); +lean_ctor_set(x_200, 1, x_133); +return x_200; +} +else +{ +size_t x_201; size_t x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; +lean_dec(x_128); +x_201 = 0; +x_202 = lean_usize_of_nat(x_189); +lean_dec(x_189); +x_203 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2; +x_204 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3; +x_205 = lean_box(0); +x_206 = l_Array_foldlMUnsafe_fold___rarg(x_203, x_204, x_124, x_201, x_202, x_205); +x_207 = lean_apply_3(x_206, x_9, x_188, x_133); +if (lean_obj_tag(x_207) == 0) +{ +lean_object* x_208; +x_208 = lean_ctor_get(x_207, 0); +lean_inc(x_208); +if (lean_obj_tag(x_208) == 0) +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; uint8_t x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; +x_209 = lean_ctor_get(x_207, 1); +lean_inc(x_209); +if (lean_is_exclusive(x_207)) { + lean_ctor_release(x_207, 0); + lean_ctor_release(x_207, 1); + x_210 = x_207; +} else { + lean_dec_ref(x_207); + x_210 = lean_box(0); +} +x_211 = lean_ctor_get(x_208, 1); +lean_inc(x_211); +if (lean_is_exclusive(x_208)) { + lean_ctor_release(x_208, 0); + lean_ctor_release(x_208, 1); + x_212 = x_208; +} else { + lean_dec_ref(x_208); + x_212 = lean_box(0); +} +x_213 = 1; +x_214 = lean_box(x_213); +if (lean_is_scalar(x_212)) { + x_215 = lean_alloc_ctor(0, 2, 0); +} else { + x_215 = x_212; +} +lean_ctor_set(x_215, 0, x_214); +lean_ctor_set(x_215, 1, x_211); +if (lean_is_scalar(x_210)) { + x_216 = lean_alloc_ctor(0, 2, 0); +} else { + x_216 = x_210; +} +lean_ctor_set(x_216, 0, x_215); +lean_ctor_set(x_216, 1, x_209); +return x_216; +} +else +{ +lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; +x_217 = lean_ctor_get(x_207, 1); +lean_inc(x_217); +if (lean_is_exclusive(x_207)) { + lean_ctor_release(x_207, 0); + lean_ctor_release(x_207, 1); + x_218 = x_207; +} else { + lean_dec_ref(x_207); + x_218 = lean_box(0); +} +x_219 = lean_ctor_get(x_208, 0); +lean_inc(x_219); +x_220 = lean_ctor_get(x_208, 1); +lean_inc(x_220); +if (lean_is_exclusive(x_208)) { + lean_ctor_release(x_208, 0); + lean_ctor_release(x_208, 1); + x_221 = x_208; +} else { + lean_dec_ref(x_208); + x_221 = lean_box(0); +} +if (lean_is_scalar(x_221)) { + x_222 = lean_alloc_ctor(1, 2, 0); +} else { + x_222 = x_221; +} +lean_ctor_set(x_222, 0, x_219); +lean_ctor_set(x_222, 1, x_220); +if (lean_is_scalar(x_218)) { + x_223 = lean_alloc_ctor(0, 2, 0); +} else { + x_223 = x_218; +} +lean_ctor_set(x_223, 0, x_222); +lean_ctor_set(x_223, 1, x_217); +return x_223; +} +} +else +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_224 = lean_ctor_get(x_207, 0); +lean_inc(x_224); +x_225 = lean_ctor_get(x_207, 1); +lean_inc(x_225); +if (lean_is_exclusive(x_207)) { + lean_ctor_release(x_207, 0); + lean_ctor_release(x_207, 1); + x_226 = x_207; +} else { + lean_dec_ref(x_207); + x_226 = lean_box(0); +} +if (lean_is_scalar(x_226)) { + x_227 = lean_alloc_ctor(1, 2, 0); +} else { + x_227 = x_226; +} +lean_ctor_set(x_227, 0, x_224); +lean_ctor_set(x_227, 1, x_225); +return x_227; +} +} +} +} +} +} +else +{ +lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_298; +x_252 = lean_ctor_get(x_126, 0); +x_253 = lean_ctor_get(x_126, 1); +lean_inc(x_253); +lean_inc(x_252); +lean_dec(x_126); +x_298 = lean_unbox(x_252); +lean_dec(x_252); +if (x_298 == 0) +{ +lean_object* x_299; lean_object* x_300; +lean_dec(x_128); +lean_dec(x_124); +x_299 = lean_box(0); +x_300 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_299, x_9, x_253, x_127); +return x_300; +} +else +{ +lean_object* x_301; uint8_t x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; lean_object* x_306; lean_object* x_307; uint8_t x_308; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_301 = lean_ctor_get(x_253, 0); +lean_inc(x_301); +x_302 = lean_ctor_get_uint8(x_253, sizeof(void*)*1); +if (lean_is_exclusive(x_253)) { + lean_ctor_release(x_253, 0); + x_303 = x_253; +} else { + lean_dec_ref(x_253); + x_303 = lean_box(0); +} +x_304 = l_Lake_instOrdJobAction; +x_305 = 1; +x_306 = lean_box(x_302); +x_307 = lean_box(x_305); +x_308 = l_instDecidableRelLe___rarg(x_304, x_306, x_307); +if (x_308 == 0) +{ +lean_object* x_309; lean_object* x_310; lean_object* x_311; +if (lean_is_scalar(x_303)) { + x_309 = lean_alloc_ctor(0, 1, 1); +} else { + x_309 = x_303; +} +lean_ctor_set(x_309, 0, x_301); +lean_ctor_set_uint8(x_309, sizeof(void*)*1, x_302); +x_310 = lean_box(0); +x_311 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_311, 0, x_310); +lean_ctor_set(x_311, 1, x_309); +x_254 = x_311; +x_255 = x_127; +goto block_297; +} +else +{ +lean_object* x_312; lean_object* x_313; lean_object* x_314; +if (lean_is_scalar(x_303)) { + x_312 = lean_alloc_ctor(0, 1, 1); +} else { + x_312 = x_303; +} +lean_ctor_set(x_312, 0, x_301); +lean_ctor_set_uint8(x_312, sizeof(void*)*1, x_305); +x_313 = lean_box(0); +x_314 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_314, 0, x_313); +lean_ctor_set(x_314, 1, x_312); +x_254 = x_314; +x_255 = x_127; +goto block_297; +} +} +block_297: +{ +lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; uint8_t x_260; +x_256 = lean_ctor_get(x_254, 1); +lean_inc(x_256); +if (lean_is_exclusive(x_254)) { + lean_ctor_release(x_254, 0); + lean_ctor_release(x_254, 1); + x_257 = x_254; +} else { + lean_dec_ref(x_254); + x_257 = lean_box(0); +} +x_258 = lean_array_get_size(x_124); +x_259 = lean_unsigned_to_nat(0u); +x_260 = lean_nat_dec_lt(x_259, x_258); +if (x_260 == 0) +{ +uint8_t x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_258); +lean_dec(x_124); +lean_dec(x_9); +x_261 = 1; +x_262 = lean_box(x_261); +if (lean_is_scalar(x_257)) { + x_263 = lean_alloc_ctor(0, 2, 0); +} else { + x_263 = x_257; +} +lean_ctor_set(x_263, 0, x_262); +lean_ctor_set(x_263, 1, x_256); +if (lean_is_scalar(x_128)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_128; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_255); +return x_264; +} +else +{ +uint8_t x_265; +x_265 = lean_nat_dec_le(x_258, x_258); +if (x_265 == 0) +{ +uint8_t x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; +lean_dec(x_258); +lean_dec(x_124); +lean_dec(x_9); +x_266 = 1; +x_267 = lean_box(x_266); +if (lean_is_scalar(x_257)) { + x_268 = lean_alloc_ctor(0, 2, 0); +} else { + x_268 = x_257; +} +lean_ctor_set(x_268, 0, x_267); +lean_ctor_set(x_268, 1, x_256); +if (lean_is_scalar(x_128)) { + x_269 = lean_alloc_ctor(0, 2, 0); +} else { + x_269 = x_128; +} +lean_ctor_set(x_269, 0, x_268); +lean_ctor_set(x_269, 1, x_255); +return x_269; +} +else +{ +size_t x_270; size_t x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; +lean_dec(x_257); +lean_dec(x_128); +x_270 = 0; +x_271 = lean_usize_of_nat(x_258); +lean_dec(x_258); +x_272 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2; +x_273 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3; +x_274 = lean_box(0); +x_275 = l_Array_foldlMUnsafe_fold___rarg(x_272, x_273, x_124, x_270, x_271, x_274); +x_276 = lean_apply_3(x_275, x_9, x_256, x_255); +if (lean_obj_tag(x_276) == 0) +{ +lean_object* x_277; +x_277 = lean_ctor_get(x_276, 0); +lean_inc(x_277); +if (lean_obj_tag(x_277) == 0) +{ +lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; uint8_t x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; +x_278 = lean_ctor_get(x_276, 1); +lean_inc(x_278); +if (lean_is_exclusive(x_276)) { + lean_ctor_release(x_276, 0); + lean_ctor_release(x_276, 1); + x_279 = x_276; +} else { + lean_dec_ref(x_276); + x_279 = lean_box(0); +} +x_280 = lean_ctor_get(x_277, 1); +lean_inc(x_280); +if (lean_is_exclusive(x_277)) { + lean_ctor_release(x_277, 0); + lean_ctor_release(x_277, 1); + x_281 = x_277; +} else { + lean_dec_ref(x_277); + x_281 = lean_box(0); +} +x_282 = 1; +x_283 = lean_box(x_282); +if (lean_is_scalar(x_281)) { + x_284 = lean_alloc_ctor(0, 2, 0); +} else { + x_284 = x_281; +} +lean_ctor_set(x_284, 0, x_283); +lean_ctor_set(x_284, 1, x_280); +if (lean_is_scalar(x_279)) { + x_285 = lean_alloc_ctor(0, 2, 0); +} else { + x_285 = x_279; +} +lean_ctor_set(x_285, 0, x_284); +lean_ctor_set(x_285, 1, x_278); +return x_285; +} +else +{ +lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; +x_286 = lean_ctor_get(x_276, 1); +lean_inc(x_286); +if (lean_is_exclusive(x_276)) { + lean_ctor_release(x_276, 0); + lean_ctor_release(x_276, 1); + x_287 = x_276; +} else { + lean_dec_ref(x_276); + x_287 = lean_box(0); +} +x_288 = lean_ctor_get(x_277, 0); +lean_inc(x_288); +x_289 = lean_ctor_get(x_277, 1); +lean_inc(x_289); +if (lean_is_exclusive(x_277)) { + lean_ctor_release(x_277, 0); + lean_ctor_release(x_277, 1); + x_290 = x_277; +} else { + lean_dec_ref(x_277); + x_290 = lean_box(0); +} +if (lean_is_scalar(x_290)) { + x_291 = lean_alloc_ctor(1, 2, 0); +} else { + x_291 = x_290; +} +lean_ctor_set(x_291, 0, x_288); +lean_ctor_set(x_291, 1, x_289); +if (lean_is_scalar(x_287)) { + x_292 = lean_alloc_ctor(0, 2, 0); +} else { + x_292 = x_287; +} +lean_ctor_set(x_292, 0, x_291); +lean_ctor_set(x_292, 1, x_286); +return x_292; +} +} +else +{ +lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; +x_293 = lean_ctor_get(x_276, 0); +lean_inc(x_293); +x_294 = lean_ctor_get(x_276, 1); +lean_inc(x_294); +if (lean_is_exclusive(x_276)) { + lean_ctor_release(x_276, 0); + lean_ctor_release(x_276, 1); + x_295 = x_276; +} else { + lean_dec_ref(x_276); + x_295 = lean_box(0); +} +if (lean_is_scalar(x_295)) { + x_296 = lean_alloc_ctor(1, 2, 0); +} else { + x_296 = x_295; +} +lean_ctor_set(x_296, 0, x_293); +lean_ctor_set(x_296, 1, x_294); +return x_296; +} +} +} +} +} +} +else +{ +uint8_t x_315; +lean_dec(x_124); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_315 = !lean_is_exclusive(x_125); +if (x_315 == 0) +{ +lean_object* x_316; uint8_t x_317; +x_316 = lean_ctor_get(x_125, 0); +lean_dec(x_316); +x_317 = !lean_is_exclusive(x_126); +if (x_317 == 0) +{ +return x_125; +} +else +{ +lean_object* x_318; lean_object* x_319; lean_object* x_320; +x_318 = lean_ctor_get(x_126, 0); +x_319 = lean_ctor_get(x_126, 1); +lean_inc(x_319); +lean_inc(x_318); +lean_dec(x_126); +x_320 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_320, 0, x_318); +lean_ctor_set(x_320, 1, x_319); +lean_ctor_set(x_125, 0, x_320); +return x_125; +} +} +else +{ +lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; +x_321 = lean_ctor_get(x_125, 1); +lean_inc(x_321); +lean_dec(x_125); +x_322 = lean_ctor_get(x_126, 0); +lean_inc(x_322); +x_323 = lean_ctor_get(x_126, 1); +lean_inc(x_323); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_324 = x_126; +} else { + lean_dec_ref(x_126); + x_324 = lean_box(0); +} +if (lean_is_scalar(x_324)) { + x_325 = lean_alloc_ctor(1, 2, 0); +} else { + x_325 = x_324; +} +lean_ctor_set(x_325, 0, x_322); +lean_ctor_set(x_325, 1, x_323); +x_326 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_326, 0, x_325); +lean_ctor_set(x_326, 1, x_321); +return x_326; +} +} +} +else +{ +uint8_t x_327; +lean_dec(x_124); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_327 = !lean_is_exclusive(x_125); +if (x_327 == 0) +{ +return x_125; +} +else +{ +lean_object* x_328; lean_object* x_329; lean_object* x_330; +x_328 = lean_ctor_get(x_125, 0); +x_329 = lean_ctor_get(x_125, 1); +lean_inc(x_329); +lean_inc(x_328); +lean_dec(x_125); +x_330 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_330, 0, x_328); +lean_ctor_set(x_330, 1, x_329); +return x_330; +} +} +} +else +{ +lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; +x_331 = lean_ctor_get(x_14, 0); +lean_inc(x_331); +lean_dec(x_14); +x_332 = lean_ctor_get(x_12, 1); +lean_inc(x_332); +lean_dec(x_12); +x_333 = lean_ctor_get(x_331, 0); +lean_inc(x_333); +x_334 = lean_ctor_get(x_331, 1); +lean_inc(x_334); +lean_dec(x_331); +x_335 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_335, 0, x_333); +lean_inc(x_4); +x_336 = l_Lake_checkHashUpToDate___rarg(x_1, x_2, x_3, x_4, x_335, x_8, x_9, x_332, x_13); +if (lean_obj_tag(x_336) == 0) +{ +lean_object* x_337; +x_337 = lean_ctor_get(x_336, 0); +lean_inc(x_337); +if (lean_obj_tag(x_337) == 0) +{ +lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; uint8_t x_387; +x_338 = lean_ctor_get(x_336, 1); +lean_inc(x_338); +if (lean_is_exclusive(x_336)) { + lean_ctor_release(x_336, 0); + lean_ctor_release(x_336, 1); + x_339 = x_336; +} else { + lean_dec_ref(x_336); + x_339 = lean_box(0); +} +x_340 = lean_ctor_get(x_337, 0); +lean_inc(x_340); +x_341 = lean_ctor_get(x_337, 1); +lean_inc(x_341); +if (lean_is_exclusive(x_337)) { + lean_ctor_release(x_337, 0); + lean_ctor_release(x_337, 1); + x_342 = x_337; +} else { + lean_dec_ref(x_337); + x_342 = lean_box(0); +} +x_387 = lean_unbox(x_340); +lean_dec(x_340); +if (x_387 == 0) +{ +lean_object* x_388; lean_object* x_389; +lean_dec(x_342); +lean_dec(x_339); +lean_dec(x_334); +x_388 = lean_box(0); +x_389 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_6, x_5, x_4, x_7, x_388, x_9, x_341, x_338); +return x_389; +} +else +{ +lean_object* x_390; uint8_t x_391; lean_object* x_392; lean_object* x_393; uint8_t x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_390 = lean_ctor_get(x_341, 0); +lean_inc(x_390); +x_391 = lean_ctor_get_uint8(x_341, sizeof(void*)*1); +if (lean_is_exclusive(x_341)) { + lean_ctor_release(x_341, 0); + x_392 = x_341; +} else { + lean_dec_ref(x_341); + x_392 = lean_box(0); +} +x_393 = l_Lake_instOrdJobAction; +x_394 = 1; +x_395 = lean_box(x_391); +x_396 = lean_box(x_394); +x_397 = l_instDecidableRelLe___rarg(x_393, x_395, x_396); +if (x_397 == 0) +{ +lean_object* x_398; lean_object* x_399; lean_object* x_400; +if (lean_is_scalar(x_392)) { + x_398 = lean_alloc_ctor(0, 1, 1); +} else { + x_398 = x_392; +} +lean_ctor_set(x_398, 0, x_390); +lean_ctor_set_uint8(x_398, sizeof(void*)*1, x_391); +x_399 = lean_box(0); +if (lean_is_scalar(x_342)) { + x_400 = lean_alloc_ctor(0, 2, 0); +} else { + x_400 = x_342; +} +lean_ctor_set(x_400, 0, x_399); +lean_ctor_set(x_400, 1, x_398); +x_343 = x_400; +x_344 = x_338; +goto block_386; +} +else +{ +lean_object* x_401; lean_object* x_402; lean_object* x_403; +if (lean_is_scalar(x_392)) { + x_401 = lean_alloc_ctor(0, 1, 1); +} else { + x_401 = x_392; +} +lean_ctor_set(x_401, 0, x_390); +lean_ctor_set_uint8(x_401, sizeof(void*)*1, x_394); +x_402 = lean_box(0); +if (lean_is_scalar(x_342)) { + x_403 = lean_alloc_ctor(0, 2, 0); +} else { + x_403 = x_342; +} +lean_ctor_set(x_403, 0, x_402); +lean_ctor_set(x_403, 1, x_401); +x_343 = x_403; +x_344 = x_338; +goto block_386; +} +} +block_386: +{ +lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; uint8_t x_349; +x_345 = lean_ctor_get(x_343, 1); +lean_inc(x_345); +if (lean_is_exclusive(x_343)) { + lean_ctor_release(x_343, 0); + lean_ctor_release(x_343, 1); + x_346 = x_343; +} else { + lean_dec_ref(x_343); + x_346 = lean_box(0); +} +x_347 = lean_array_get_size(x_334); +x_348 = lean_unsigned_to_nat(0u); +x_349 = lean_nat_dec_lt(x_348, x_347); +if (x_349 == 0) +{ +uint8_t x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; +lean_dec(x_347); +lean_dec(x_334); +lean_dec(x_9); +x_350 = 1; +x_351 = lean_box(x_350); +if (lean_is_scalar(x_346)) { + x_352 = lean_alloc_ctor(0, 2, 0); +} else { + x_352 = x_346; +} +lean_ctor_set(x_352, 0, x_351); +lean_ctor_set(x_352, 1, x_345); +if (lean_is_scalar(x_339)) { + x_353 = lean_alloc_ctor(0, 2, 0); +} else { + x_353 = x_339; +} +lean_ctor_set(x_353, 0, x_352); +lean_ctor_set(x_353, 1, x_344); +return x_353; +} +else +{ +uint8_t x_354; +x_354 = lean_nat_dec_le(x_347, x_347); +if (x_354 == 0) +{ +uint8_t x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; +lean_dec(x_347); +lean_dec(x_334); +lean_dec(x_9); +x_355 = 1; +x_356 = lean_box(x_355); +if (lean_is_scalar(x_346)) { + x_357 = lean_alloc_ctor(0, 2, 0); +} else { + x_357 = x_346; +} +lean_ctor_set(x_357, 0, x_356); +lean_ctor_set(x_357, 1, x_345); +if (lean_is_scalar(x_339)) { + x_358 = lean_alloc_ctor(0, 2, 0); +} else { + x_358 = x_339; +} +lean_ctor_set(x_358, 0, x_357); +lean_ctor_set(x_358, 1, x_344); +return x_358; +} +else +{ +size_t x_359; size_t x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; +lean_dec(x_346); +lean_dec(x_339); +x_359 = 0; +x_360 = lean_usize_of_nat(x_347); +lean_dec(x_347); +x_361 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2; +x_362 = l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3; +x_363 = lean_box(0); +x_364 = l_Array_foldlMUnsafe_fold___rarg(x_361, x_362, x_334, x_359, x_360, x_363); +x_365 = lean_apply_3(x_364, x_9, x_345, x_344); +if (lean_obj_tag(x_365) == 0) +{ +lean_object* x_366; +x_366 = lean_ctor_get(x_365, 0); +lean_inc(x_366); +if (lean_obj_tag(x_366) == 0) +{ +lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; uint8_t x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; +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); +} +x_369 = lean_ctor_get(x_366, 1); +lean_inc(x_369); +if (lean_is_exclusive(x_366)) { + lean_ctor_release(x_366, 0); + lean_ctor_release(x_366, 1); + x_370 = x_366; +} else { + lean_dec_ref(x_366); + x_370 = lean_box(0); +} +x_371 = 1; +x_372 = lean_box(x_371); +if (lean_is_scalar(x_370)) { + x_373 = lean_alloc_ctor(0, 2, 0); +} else { + x_373 = x_370; +} +lean_ctor_set(x_373, 0, x_372); +lean_ctor_set(x_373, 1, x_369); +if (lean_is_scalar(x_368)) { + x_374 = lean_alloc_ctor(0, 2, 0); +} else { + x_374 = x_368; +} +lean_ctor_set(x_374, 0, x_373); +lean_ctor_set(x_374, 1, x_367); +return x_374; +} +else +{ +lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; +x_375 = lean_ctor_get(x_365, 1); +lean_inc(x_375); +if (lean_is_exclusive(x_365)) { + lean_ctor_release(x_365, 0); + lean_ctor_release(x_365, 1); + x_376 = x_365; +} else { + lean_dec_ref(x_365); + x_376 = lean_box(0); +} +x_377 = lean_ctor_get(x_366, 0); +lean_inc(x_377); +x_378 = lean_ctor_get(x_366, 1); +lean_inc(x_378); +if (lean_is_exclusive(x_366)) { + lean_ctor_release(x_366, 0); + lean_ctor_release(x_366, 1); + x_379 = x_366; +} else { + lean_dec_ref(x_366); + x_379 = lean_box(0); +} +if (lean_is_scalar(x_379)) { + x_380 = lean_alloc_ctor(1, 2, 0); +} else { + x_380 = x_379; +} +lean_ctor_set(x_380, 0, x_377); +lean_ctor_set(x_380, 1, x_378); +if (lean_is_scalar(x_376)) { + x_381 = lean_alloc_ctor(0, 2, 0); +} else { + x_381 = x_376; +} +lean_ctor_set(x_381, 0, x_380); +lean_ctor_set(x_381, 1, x_375); +return x_381; +} +} +else +{ +lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; +x_382 = lean_ctor_get(x_365, 0); +lean_inc(x_382); +x_383 = lean_ctor_get(x_365, 1); +lean_inc(x_383); +if (lean_is_exclusive(x_365)) { + lean_ctor_release(x_365, 0); + lean_ctor_release(x_365, 1); + x_384 = x_365; +} else { + lean_dec_ref(x_365); + x_384 = lean_box(0); +} +if (lean_is_scalar(x_384)) { + x_385 = lean_alloc_ctor(1, 2, 0); +} else { + x_385 = x_384; +} +lean_ctor_set(x_385, 0, x_382); +lean_ctor_set(x_385, 1, x_383); +return x_385; +} +} +} +} +} +else +{ +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_dec(x_334); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_404 = lean_ctor_get(x_336, 1); +lean_inc(x_404); +if (lean_is_exclusive(x_336)) { + lean_ctor_release(x_336, 0); + lean_ctor_release(x_336, 1); + x_405 = x_336; +} else { + lean_dec_ref(x_336); + x_405 = lean_box(0); +} +x_406 = lean_ctor_get(x_337, 0); +lean_inc(x_406); +x_407 = lean_ctor_get(x_337, 1); +lean_inc(x_407); +if (lean_is_exclusive(x_337)) { + lean_ctor_release(x_337, 0); + lean_ctor_release(x_337, 1); + x_408 = x_337; +} else { + lean_dec_ref(x_337); + x_408 = lean_box(0); +} +if (lean_is_scalar(x_408)) { + x_409 = lean_alloc_ctor(1, 2, 0); +} else { + x_409 = x_408; +} +lean_ctor_set(x_409, 0, x_406); +lean_ctor_set(x_409, 1, x_407); +if (lean_is_scalar(x_405)) { + x_410 = lean_alloc_ctor(0, 2, 0); +} else { + x_410 = x_405; +} +lean_ctor_set(x_410, 0, x_409); +lean_ctor_set(x_410, 1, x_404); +return x_410; +} +} +else +{ +lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; +lean_dec(x_334); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_411 = lean_ctor_get(x_336, 0); +lean_inc(x_411); +x_412 = lean_ctor_get(x_336, 1); +lean_inc(x_412); +if (lean_is_exclusive(x_336)) { + lean_ctor_release(x_336, 0); + lean_ctor_release(x_336, 1); + x_413 = x_336; +} else { + lean_dec_ref(x_336); + x_413 = lean_box(0); +} +if (lean_is_scalar(x_413)) { + x_414 = lean_alloc_ctor(1, 2, 0); +} else { + x_414 = x_413; +} +lean_ctor_set(x_414, 0, x_411); +lean_ctor_set(x_414, 1, x_412); +return x_414; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_buildUnlessUpToDate_x3f___rarg___boxed), 11, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +uint8_t x_9; lean_object* x_10; +x_9 = lean_unbox(x_4); +lean_dec(x_4); +x_10 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1(x_1, x_2, x_3, x_9, x_5, x_6, x_7, x_8); +lean_dec(x_5); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_1); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; lean_object* x_13; +x_12 = lean_unbox(x_7); +lean_dec(x_7); +x_13 = l_Lake_buildUnlessUpToDate_x3f___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_12, x_8, x_9, x_10, x_11); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, uint8_t x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; +x_12 = l_Lake_buildUnlessUpToDate_x3f___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_12); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_12, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_13, 0); +lean_dec(x_17); +x_18 = lean_box(0); +lean_ctor_set(x_13, 0, x_18); +return x_12; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_13, 1); +lean_inc(x_19); +lean_dec(x_13); +x_20 = lean_box(0); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_19); +lean_ctor_set(x_12, 0, x_21); +return x_12; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_12, 1); +lean_inc(x_22); +lean_dec(x_12); +x_23 = lean_ctor_get(x_13, 1); +lean_inc(x_23); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_24 = x_13; +} else { + lean_dec_ref(x_13); + x_24 = lean_box(0); +} +x_25 = lean_box(0); +if (lean_is_scalar(x_24)) { + x_26 = lean_alloc_ctor(0, 2, 0); +} else { + x_26 = x_24; +} +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_23); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_22); +return x_27; +} +} +else +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_12); +if (x_28 == 0) +{ +lean_object* x_29; uint8_t x_30; +x_29 = lean_ctor_get(x_12, 0); +lean_dec(x_29); +x_30 = !lean_is_exclusive(x_13); +if (x_30 == 0) +{ +return x_12; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_13, 0); +x_32 = lean_ctor_get(x_13, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_13); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +lean_ctor_set(x_12, 0, x_33); +return x_12; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_12, 1); +lean_inc(x_34); +lean_dec(x_12); +x_35 = lean_ctor_get(x_13, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_13, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_37 = x_13; +} else { + lean_dec_ref(x_13); + x_37 = lean_box(0); +} +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_36); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_34); +return x_39; +} +} +} +else +{ +uint8_t x_40; +x_40 = !lean_is_exclusive(x_12); +if (x_40 == 0) +{ +return x_12; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_12, 0); +x_42 = lean_ctor_get(x_12, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_12); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_buildUnlessUpToDate___rarg___boxed), 11, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; lean_object* x_13; +x_12 = lean_unbox(x_7); +lean_dec(x_7); +x_13 = l_Lake_buildUnlessUpToDate___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_12, x_8, x_9, x_10, x_11); +return x_13; +} +} +static lean_object* _init_l_Lake_cacheFileHash___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(".hash", 5); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_cacheFileHash(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_computeFileHash(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_4 = lean_ctor_get(x_3, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = l_Lake_cacheFileHash___closed__1; +x_7 = lean_string_append(x_1, x_6); +lean_inc(x_7); +x_8 = l_Lake_createParentDirs(x_7, x_5); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; uint64_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_unbox_uint64(x_4); +lean_dec(x_4); +x_11 = lean_uint64_to_nat(x_10); +x_12 = l___private_Init_Data_Repr_0__Nat_reprFast(x_11); +x_13 = l_IO_FS_writeFile(x_7, x_12, x_9); +lean_dec(x_12); +lean_dec(x_7); +return x_13; +} +else +{ +uint8_t x_14; +lean_dec(x_7); +lean_dec(x_4); +x_14 = !lean_is_exclusive(x_8); +if (x_14 == 0) +{ +return x_8; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_8, 0); +x_16 = lean_ctor_get(x_8, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_8); +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_16); +return x_17; +} +} +} +else +{ +uint8_t x_18; +lean_dec(x_1); +x_18 = !lean_is_exclusive(x_3); +if (x_18 == 0) +{ +return x_3; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_3, 0); +x_20 = lean_ctor_get(x_3, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_3); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +return x_21; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_clearFileHash(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_3 = l_Lake_cacheFileHash___closed__1; +x_4 = lean_string_append(x_1, x_3); +x_5 = lean_io_remove_file(x_4, x_2); +lean_dec(x_4); +if (lean_obj_tag(x_5) == 0) +{ +return x_5; +} +else +{ +lean_object* x_6; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +if (lean_obj_tag(x_6) == 11) +{ +uint8_t x_7; +lean_dec(x_6); +x_7 = !lean_is_exclusive(x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_ctor_get(x_5, 0); +lean_dec(x_8); +x_9 = lean_box(0); +lean_ctor_set_tag(x_5, 0); +lean_ctor_set(x_5, 0, x_9); +return x_5; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_5, 1); +lean_inc(x_10); +lean_dec(x_5); +x_11 = lean_box(0); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_10); +return x_12; +} +} +else +{ +uint8_t x_13; +x_13 = !lean_is_exclusive(x_5); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_5, 0); +lean_dec(x_14); +return x_5; +} +else +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_5, 1); +lean_inc(x_15); +lean_dec(x_5); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_6); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_fetchFileHash___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; uint8_t x_175; +x_175 = !lean_is_exclusive(x_5); +if (x_175 == 0) +{ +lean_object* x_176; lean_object* x_177; +x_176 = lean_ctor_get(x_5, 0); +x_177 = l_Lake_computeFileHash(x_1, x_6); +if (lean_obj_tag(x_177) == 0) +{ +uint8_t x_178; +x_178 = !lean_is_exclusive(x_177); +if (x_178 == 0) +{ +lean_object* x_179; +x_179 = lean_ctor_get(x_177, 1); +lean_ctor_set(x_177, 1, x_5); +x_7 = x_177; +x_8 = x_179; +goto block_174; +} +else +{ +lean_object* x_180; lean_object* x_181; lean_object* x_182; +x_180 = lean_ctor_get(x_177, 0); +x_181 = lean_ctor_get(x_177, 1); +lean_inc(x_181); +lean_inc(x_180); +lean_dec(x_177); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_180); +lean_ctor_set(x_182, 1, x_5); +x_7 = x_182; +x_8 = x_181; +goto block_174; +} +} +else +{ +uint8_t x_183; +x_183 = !lean_is_exclusive(x_177); +if (x_183 == 0) +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; uint8_t x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; +x_184 = lean_ctor_get(x_177, 0); +x_185 = lean_ctor_get(x_177, 1); +x_186 = lean_io_error_to_string(x_184); +x_187 = 3; +x_188 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_188, 0, x_186); +lean_ctor_set_uint8(x_188, sizeof(void*)*1, x_187); +x_189 = lean_array_get_size(x_176); +x_190 = lean_array_push(x_176, x_188); +lean_ctor_set(x_5, 0, x_190); +lean_ctor_set(x_177, 1, x_5); +lean_ctor_set(x_177, 0, x_189); +x_7 = x_177; +x_8 = x_185; +goto block_174; +} +else +{ +lean_object* x_191; lean_object* x_192; lean_object* x_193; uint8_t x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; +x_191 = lean_ctor_get(x_177, 0); +x_192 = lean_ctor_get(x_177, 1); +lean_inc(x_192); +lean_inc(x_191); +lean_dec(x_177); +x_193 = lean_io_error_to_string(x_191); +x_194 = 3; +x_195 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_195, 0, x_193); +lean_ctor_set_uint8(x_195, sizeof(void*)*1, x_194); +x_196 = lean_array_get_size(x_176); +x_197 = lean_array_push(x_176, x_195); +lean_ctor_set(x_5, 0, x_197); +x_198 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_198, 0, x_196); +lean_ctor_set(x_198, 1, x_5); +x_7 = x_198; +x_8 = x_192; +goto block_174; +} +} +} +else +{ +lean_object* x_199; uint8_t x_200; lean_object* x_201; +x_199 = lean_ctor_get(x_5, 0); +x_200 = lean_ctor_get_uint8(x_5, sizeof(void*)*1); +lean_inc(x_199); +lean_dec(x_5); +x_201 = l_Lake_computeFileHash(x_1, x_6); +if (lean_obj_tag(x_201) == 0) +{ +lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; +x_202 = lean_ctor_get(x_201, 0); +lean_inc(x_202); +x_203 = lean_ctor_get(x_201, 1); +lean_inc(x_203); +if (lean_is_exclusive(x_201)) { + lean_ctor_release(x_201, 0); + lean_ctor_release(x_201, 1); + x_204 = x_201; +} else { + lean_dec_ref(x_201); + x_204 = lean_box(0); +} +x_205 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_205, 0, x_199); +lean_ctor_set_uint8(x_205, sizeof(void*)*1, x_200); +if (lean_is_scalar(x_204)) { + x_206 = lean_alloc_ctor(0, 2, 0); +} else { + x_206 = x_204; +} +lean_ctor_set(x_206, 0, x_202); +lean_ctor_set(x_206, 1, x_205); +x_7 = x_206; +x_8 = x_203; +goto block_174; +} +else +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; uint8_t x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; +x_207 = lean_ctor_get(x_201, 0); +lean_inc(x_207); +x_208 = lean_ctor_get(x_201, 1); +lean_inc(x_208); +if (lean_is_exclusive(x_201)) { + lean_ctor_release(x_201, 0); + lean_ctor_release(x_201, 1); + x_209 = x_201; +} else { + lean_dec_ref(x_201); + x_209 = lean_box(0); +} +x_210 = lean_io_error_to_string(x_207); +x_211 = 3; +x_212 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_212, 0, x_210); +lean_ctor_set_uint8(x_212, sizeof(void*)*1, x_211); +x_213 = lean_array_get_size(x_199); +x_214 = lean_array_push(x_199, x_212); +x_215 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_215, 0, x_214); +lean_ctor_set_uint8(x_215, sizeof(void*)*1, x_200); +if (lean_is_scalar(x_209)) { + x_216 = lean_alloc_ctor(1, 2, 0); +} else { + x_216 = x_209; +} +lean_ctor_set(x_216, 0, x_213); +lean_ctor_set(x_216, 1, x_215); +x_7 = x_216; +x_8 = x_208; +goto block_174; +} +} +block_174: +{ +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_7); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_90; +x_10 = lean_ctor_get(x_7, 0); +x_11 = lean_ctor_get(x_7, 1); +x_90 = !lean_is_exclusive(x_11); +if (x_90 == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_11, 0); +lean_inc(x_2); +x_92 = l_Lake_createParentDirs(x_2, x_8); +if (lean_obj_tag(x_92) == 0) +{ +lean_object* x_93; lean_object* x_94; +x_93 = lean_ctor_get(x_92, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_92, 1); +lean_inc(x_94); +lean_dec(x_92); +lean_ctor_set(x_7, 0, x_93); +x_12 = x_7; +x_13 = x_94; +goto block_89; +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_95 = lean_ctor_get(x_92, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_92, 1); +lean_inc(x_96); +lean_dec(x_92); +x_97 = lean_io_error_to_string(x_95); +x_98 = 3; +x_99 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set_uint8(x_99, sizeof(void*)*1, x_98); +x_100 = lean_array_get_size(x_91); +x_101 = lean_array_push(x_91, x_99); +lean_ctor_set(x_11, 0, x_101); +lean_ctor_set_tag(x_7, 1); +lean_ctor_set(x_7, 0, x_100); +x_12 = x_7; +x_13 = x_96; +goto block_89; +} +} +else +{ +lean_object* x_102; uint8_t x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_11, 0); +x_103 = lean_ctor_get_uint8(x_11, sizeof(void*)*1); +lean_inc(x_102); +lean_dec(x_11); +lean_inc(x_2); +x_104 = l_Lake_createParentDirs(x_2, x_8); +if (lean_obj_tag(x_104) == 0) +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +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 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_107, 0, x_102); +lean_ctor_set_uint8(x_107, sizeof(void*)*1, x_103); +lean_ctor_set(x_7, 1, x_107); +lean_ctor_set(x_7, 0, x_105); +x_12 = x_7; +x_13 = x_106; +goto block_89; +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; uint8_t x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_108 = lean_ctor_get(x_104, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_104, 1); +lean_inc(x_109); +lean_dec(x_104); +x_110 = lean_io_error_to_string(x_108); +x_111 = 3; +x_112 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set_uint8(x_112, sizeof(void*)*1, x_111); +x_113 = lean_array_get_size(x_102); +x_114 = lean_array_push(x_102, x_112); +x_115 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_115, 0, x_114); +lean_ctor_set_uint8(x_115, sizeof(void*)*1, x_103); +lean_ctor_set_tag(x_7, 1); +lean_ctor_set(x_7, 1, x_115); +lean_ctor_set(x_7, 0, x_113); +x_12 = x_7; +x_13 = x_109; +goto block_89; +} +} +block_89: +{ +if (lean_obj_tag(x_12) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_12); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; uint64_t x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_15 = lean_ctor_get(x_12, 1); +x_16 = lean_ctor_get(x_12, 0); +lean_dec(x_16); +x_17 = lean_unbox_uint64(x_10); +x_18 = lean_uint64_to_nat(x_17); +x_19 = l___private_Init_Data_Repr_0__Nat_reprFast(x_18); +x_20 = !lean_is_exclusive(x_15); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_15, 0); +x_22 = l_IO_FS_writeFile(x_2, x_19, x_13); +lean_dec(x_19); +lean_dec(x_2); +if (lean_obj_tag(x_22) == 0) +{ +uint8_t x_23; +x_23 = !lean_is_exclusive(x_22); +if (x_23 == 0) +{ +lean_object* x_24; +x_24 = lean_ctor_get(x_22, 0); +lean_dec(x_24); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set(x_22, 0, x_12); +return x_22; +} +else +{ +lean_object* x_25; lean_object* x_26; +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +lean_dec(x_22); +lean_ctor_set(x_12, 0, x_10); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_12); +lean_ctor_set(x_26, 1, x_25); +return x_26; +} +} +else +{ +uint8_t x_27; +lean_dec(x_10); +x_27 = !lean_is_exclusive(x_22); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_22, 0); +x_29 = lean_io_error_to_string(x_28); +x_30 = 3; +x_31 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set_uint8(x_31, sizeof(void*)*1, x_30); +x_32 = lean_array_get_size(x_21); +x_33 = lean_array_push(x_21, x_31); +lean_ctor_set(x_15, 0, x_33); +lean_ctor_set_tag(x_12, 1); +lean_ctor_set(x_12, 0, x_32); +lean_ctor_set_tag(x_22, 0); +lean_ctor_set(x_22, 0, x_12); +return x_22; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_34 = lean_ctor_get(x_22, 0); +x_35 = lean_ctor_get(x_22, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_22); +x_36 = lean_io_error_to_string(x_34); +x_37 = 3; +x_38 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set_uint8(x_38, sizeof(void*)*1, x_37); +x_39 = lean_array_get_size(x_21); +x_40 = lean_array_push(x_21, x_38); +lean_ctor_set(x_15, 0, x_40); +lean_ctor_set_tag(x_12, 1); +lean_ctor_set(x_12, 0, x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_12); +lean_ctor_set(x_41, 1, x_35); +return x_41; +} +} +} +else +{ +lean_object* x_42; uint8_t x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_15, 0); +x_43 = lean_ctor_get_uint8(x_15, sizeof(void*)*1); +lean_inc(x_42); +lean_dec(x_15); +x_44 = l_IO_FS_writeFile(x_2, x_19, x_13); +lean_dec(x_19); +lean_dec(x_2); +if (lean_obj_tag(x_44) == 0) +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_45 = lean_ctor_get(x_44, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_46 = x_44; +} else { + lean_dec_ref(x_44); + x_46 = lean_box(0); +} +x_47 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_47, 0, x_42); +lean_ctor_set_uint8(x_47, sizeof(void*)*1, x_43); +lean_ctor_set(x_12, 1, x_47); +lean_ctor_set(x_12, 0, x_10); +if (lean_is_scalar(x_46)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_46; +} +lean_ctor_set(x_48, 0, x_12); +lean_ctor_set(x_48, 1, x_45); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_10); +x_49 = lean_ctor_get(x_44, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_44, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_51 = x_44; +} else { + lean_dec_ref(x_44); + x_51 = lean_box(0); +} +x_52 = lean_io_error_to_string(x_49); +x_53 = 3; +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_53); +x_55 = lean_array_get_size(x_42); +x_56 = lean_array_push(x_42, x_54); +x_57 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set_uint8(x_57, sizeof(void*)*1, x_43); +lean_ctor_set_tag(x_12, 1); +lean_ctor_set(x_12, 1, x_57); +lean_ctor_set(x_12, 0, x_55); +if (lean_is_scalar(x_51)) { + x_58 = lean_alloc_ctor(0, 2, 0); +} else { + x_58 = x_51; + lean_ctor_set_tag(x_58, 0); +} +lean_ctor_set(x_58, 0, x_12); +lean_ctor_set(x_58, 1, x_50); +return x_58; +} +} +} +else +{ +lean_object* x_59; uint64_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; lean_object* x_65; lean_object* x_66; +x_59 = lean_ctor_get(x_12, 1); +lean_inc(x_59); +lean_dec(x_12); +x_60 = lean_unbox_uint64(x_10); +x_61 = lean_uint64_to_nat(x_60); +x_62 = l___private_Init_Data_Repr_0__Nat_reprFast(x_61); +x_63 = lean_ctor_get(x_59, 0); +lean_inc(x_63); +x_64 = lean_ctor_get_uint8(x_59, sizeof(void*)*1); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + x_65 = x_59; +} else { + lean_dec_ref(x_59); + x_65 = lean_box(0); +} +x_66 = l_IO_FS_writeFile(x_2, x_62, x_13); +lean_dec(x_62); +lean_dec(x_2); +if (lean_obj_tag(x_66) == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_67 = lean_ctor_get(x_66, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + lean_ctor_release(x_66, 1); + x_68 = x_66; +} else { + lean_dec_ref(x_66); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_65)) { + x_69 = lean_alloc_ctor(0, 1, 1); +} else { + x_69 = x_65; +} +lean_ctor_set(x_69, 0, x_63); +lean_ctor_set_uint8(x_69, sizeof(void*)*1, x_64); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_10); +lean_ctor_set(x_70, 1, x_69); +if (lean_is_scalar(x_68)) { + x_71 = lean_alloc_ctor(0, 2, 0); +} else { + x_71 = x_68; +} +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_67); +return x_71; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +lean_dec(x_10); +x_72 = lean_ctor_get(x_66, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_66, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + lean_ctor_release(x_66, 1); + x_74 = x_66; +} else { + lean_dec_ref(x_66); + x_74 = lean_box(0); +} +x_75 = lean_io_error_to_string(x_72); +x_76 = 3; +x_77 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_77, 0, x_75); +lean_ctor_set_uint8(x_77, sizeof(void*)*1, x_76); +x_78 = lean_array_get_size(x_63); +x_79 = lean_array_push(x_63, x_77); +if (lean_is_scalar(x_65)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_65; +} +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_64); +x_81 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_81, 0, x_78); +lean_ctor_set(x_81, 1, x_80); +if (lean_is_scalar(x_74)) { + x_82 = lean_alloc_ctor(0, 2, 0); +} else { + x_82 = x_74; + lean_ctor_set_tag(x_82, 0); +} +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_73); +return x_82; +} +} +} +else +{ +uint8_t x_83; +lean_dec(x_10); +lean_dec(x_2); +x_83 = !lean_is_exclusive(x_12); +if (x_83 == 0) +{ +lean_object* x_84; +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_12); +lean_ctor_set(x_84, 1, x_13); +return x_84; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_85 = lean_ctor_get(x_12, 0); +x_86 = lean_ctor_get(x_12, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_12); +x_87 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set(x_87, 1, x_86); +x_88 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_13); +return x_88; +} +} +} +} +else +{ +lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_151; uint8_t x_152; lean_object* x_153; lean_object* x_154; +x_116 = lean_ctor_get(x_7, 0); +x_117 = lean_ctor_get(x_7, 1); +lean_inc(x_117); +lean_inc(x_116); +lean_dec(x_7); +x_151 = lean_ctor_get(x_117, 0); +lean_inc(x_151); +x_152 = lean_ctor_get_uint8(x_117, sizeof(void*)*1); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + x_153 = x_117; +} else { + lean_dec_ref(x_117); + x_153 = lean_box(0); +} +lean_inc(x_2); +x_154 = l_Lake_createParentDirs(x_2, x_8); +if (lean_obj_tag(x_154) == 0) +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +x_155 = lean_ctor_get(x_154, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_154, 1); +lean_inc(x_156); +lean_dec(x_154); +if (lean_is_scalar(x_153)) { + x_157 = lean_alloc_ctor(0, 1, 1); +} else { + x_157 = x_153; +} +lean_ctor_set(x_157, 0, x_151); +lean_ctor_set_uint8(x_157, sizeof(void*)*1, x_152); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_155); +lean_ctor_set(x_158, 1, x_157); +x_118 = x_158; +x_119 = x_156; +goto block_150; +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; uint8_t x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +x_159 = lean_ctor_get(x_154, 0); +lean_inc(x_159); +x_160 = lean_ctor_get(x_154, 1); +lean_inc(x_160); +lean_dec(x_154); +x_161 = lean_io_error_to_string(x_159); +x_162 = 3; +x_163 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_163, 0, x_161); +lean_ctor_set_uint8(x_163, sizeof(void*)*1, x_162); +x_164 = lean_array_get_size(x_151); +x_165 = lean_array_push(x_151, x_163); +if (lean_is_scalar(x_153)) { + x_166 = lean_alloc_ctor(0, 1, 1); +} else { + x_166 = x_153; +} +lean_ctor_set(x_166, 0, x_165); +lean_ctor_set_uint8(x_166, sizeof(void*)*1, x_152); +x_167 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_166); +x_118 = x_167; +x_119 = x_160; +goto block_150; +} +block_150: +{ +if (lean_obj_tag(x_118) == 0) +{ +lean_object* x_120; lean_object* x_121; uint64_t x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; +x_120 = lean_ctor_get(x_118, 1); +lean_inc(x_120); +if (lean_is_exclusive(x_118)) { + lean_ctor_release(x_118, 0); + lean_ctor_release(x_118, 1); + x_121 = x_118; +} else { + lean_dec_ref(x_118); + x_121 = lean_box(0); +} +x_122 = lean_unbox_uint64(x_116); +x_123 = lean_uint64_to_nat(x_122); +x_124 = l___private_Init_Data_Repr_0__Nat_reprFast(x_123); +x_125 = lean_ctor_get(x_120, 0); +lean_inc(x_125); +x_126 = lean_ctor_get_uint8(x_120, sizeof(void*)*1); +if (lean_is_exclusive(x_120)) { + lean_ctor_release(x_120, 0); + x_127 = x_120; +} else { + lean_dec_ref(x_120); + x_127 = lean_box(0); +} +x_128 = l_IO_FS_writeFile(x_2, x_124, x_119); +lean_dec(x_124); +lean_dec(x_2); +if (lean_obj_tag(x_128) == 0) +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; +x_129 = lean_ctor_get(x_128, 1); +lean_inc(x_129); +if (lean_is_exclusive(x_128)) { + lean_ctor_release(x_128, 0); + lean_ctor_release(x_128, 1); + x_130 = x_128; +} else { + lean_dec_ref(x_128); + x_130 = lean_box(0); +} +if (lean_is_scalar(x_127)) { + x_131 = lean_alloc_ctor(0, 1, 1); +} else { + x_131 = x_127; +} +lean_ctor_set(x_131, 0, x_125); +lean_ctor_set_uint8(x_131, sizeof(void*)*1, x_126); +if (lean_is_scalar(x_121)) { + x_132 = lean_alloc_ctor(0, 2, 0); +} else { + x_132 = x_121; +} +lean_ctor_set(x_132, 0, x_116); +lean_ctor_set(x_132, 1, x_131); +if (lean_is_scalar(x_130)) { + x_133 = lean_alloc_ctor(0, 2, 0); +} else { + x_133 = x_130; +} +lean_ctor_set(x_133, 0, x_132); +lean_ctor_set(x_133, 1, x_129); +return x_133; +} +else +{ +lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; uint8_t x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; +lean_dec(x_116); +x_134 = lean_ctor_get(x_128, 0); +lean_inc(x_134); +x_135 = lean_ctor_get(x_128, 1); +lean_inc(x_135); +if (lean_is_exclusive(x_128)) { + lean_ctor_release(x_128, 0); + lean_ctor_release(x_128, 1); + x_136 = x_128; +} else { + lean_dec_ref(x_128); + x_136 = lean_box(0); +} +x_137 = lean_io_error_to_string(x_134); +x_138 = 3; +x_139 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_139, 0, x_137); +lean_ctor_set_uint8(x_139, sizeof(void*)*1, x_138); +x_140 = lean_array_get_size(x_125); +x_141 = lean_array_push(x_125, x_139); +if (lean_is_scalar(x_127)) { + x_142 = lean_alloc_ctor(0, 1, 1); +} else { + x_142 = x_127; +} +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set_uint8(x_142, sizeof(void*)*1, x_126); +if (lean_is_scalar(x_121)) { + x_143 = lean_alloc_ctor(1, 2, 0); +} else { + x_143 = x_121; + lean_ctor_set_tag(x_143, 1); +} +lean_ctor_set(x_143, 0, x_140); +lean_ctor_set(x_143, 1, x_142); +if (lean_is_scalar(x_136)) { + x_144 = lean_alloc_ctor(0, 2, 0); +} else { + x_144 = x_136; + lean_ctor_set_tag(x_144, 0); +} +lean_ctor_set(x_144, 0, x_143); +lean_ctor_set(x_144, 1, x_135); +return x_144; +} +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; +lean_dec(x_116); +lean_dec(x_2); +x_145 = lean_ctor_get(x_118, 0); +lean_inc(x_145); +x_146 = lean_ctor_get(x_118, 1); +lean_inc(x_146); +if (lean_is_exclusive(x_118)) { + lean_ctor_release(x_118, 0); + lean_ctor_release(x_118, 1); + x_147 = x_118; +} else { + lean_dec_ref(x_118); + x_147 = lean_box(0); +} +if (lean_is_scalar(x_147)) { + x_148 = lean_alloc_ctor(1, 2, 0); +} else { + x_148 = x_147; +} +lean_ctor_set(x_148, 0, x_145); +lean_ctor_set(x_148, 1, x_146); +x_149 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_149, 0, x_148); +lean_ctor_set(x_149, 1, x_119); +return x_149; +} +} +} +} +else +{ +uint8_t x_168; +lean_dec(x_2); +x_168 = !lean_is_exclusive(x_7); +if (x_168 == 0) +{ +lean_object* x_169; +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_7); +lean_ctor_set(x_169, 1, x_8); +return x_169; +} +else +{ +lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; +x_170 = lean_ctor_get(x_7, 0); +x_171 = lean_ctor_get(x_7, 1); +lean_inc(x_171); +lean_inc(x_170); +lean_dec(x_7); +x_172 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_172, 0, x_170); +lean_ctor_set(x_172, 1, x_171); +x_173 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_173, 0, x_172); +lean_ctor_set(x_173, 1, x_8); +return x_173; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_fetchFileHash(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_5 = l_Lake_cacheFileHash___closed__1; +lean_inc(x_1); +x_6 = lean_string_append(x_1, x_5); +x_7 = lean_ctor_get(x_2, 0); +x_8 = lean_ctor_get_uint8(x_7, sizeof(void*)*1 + 1); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_box(0); +x_10 = l_Lake_fetchFileHash___lambda__1(x_1, x_6, x_9, x_2, x_3, x_4); +lean_dec(x_1); +return x_10; +} +else +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_3); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = l_Lake_Hash_load_x3f(x_6, x_4); +x_13 = !lean_is_exclusive(x_12); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_12, 1); +lean_free_object(x_12); +x_16 = lean_box(0); +x_17 = l_Lake_fetchFileHash___lambda__1(x_1, x_6, x_16, x_2, x_3, x_15); +lean_dec(x_1); +return x_17; +} +else +{ +lean_object* x_18; lean_object* x_19; +lean_dec(x_6); +lean_dec(x_1); +x_18 = lean_ctor_get(x_14, 0); +lean_inc(x_18); +lean_dec(x_14); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_3); +lean_ctor_set(x_12, 0, x_19); +return x_12; +} +} +else +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_12, 0); +x_21 = lean_ctor_get(x_12, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_12); +if (lean_obj_tag(x_20) == 0) +{ +lean_object* x_22; lean_object* x_23; +x_22 = lean_box(0); +x_23 = l_Lake_fetchFileHash___lambda__1(x_1, x_6, x_22, x_2, x_3, x_21); +lean_dec(x_1); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +lean_dec(x_6); +lean_dec(x_1); +x_24 = lean_ctor_get(x_20, 0); +lean_inc(x_24); +lean_dec(x_20); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_3); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_21); +return x_26; +} +} +} +else +{ +lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_27 = lean_ctor_get(x_3, 0); +x_28 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_27); +lean_dec(x_3); +x_29 = l_Lake_Hash_load_x3f(x_6, x_4); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_29, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_32 = x_29; +} else { + lean_dec_ref(x_29); + x_32 = lean_box(0); +} +x_33 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_33, 0, x_27); +lean_ctor_set_uint8(x_33, sizeof(void*)*1, x_28); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_32); +x_34 = lean_box(0); +x_35 = l_Lake_fetchFileHash___lambda__1(x_1, x_6, x_34, x_2, x_33, x_31); +lean_dec(x_1); +return x_35; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_6); +lean_dec(x_1); +x_36 = lean_ctor_get(x_30, 0); +lean_inc(x_36); +lean_dec(x_30); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_33); +if (lean_is_scalar(x_32)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_32; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_31); +return x_38; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_fetchFileHash___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_fetchFileHash___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_fetchFileHash___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_fetchFileHash(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_fetchFileTrace(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; +lean_inc(x_1); +x_5 = l_Lake_fetchFileHash(x_1, x_2, x_3, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; lean_object* x_8; uint8_t x_9; +x_7 = lean_ctor_get(x_6, 1); +lean_inc(x_7); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = !lean_is_exclusive(x_6); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_10 = lean_ctor_get(x_6, 0); +x_11 = lean_ctor_get(x_6, 1); +lean_dec(x_11); +x_12 = !lean_is_exclusive(x_7); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_7, 0); +x_14 = lean_io_metadata(x_1, x_8); +lean_dec(x_1); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 0); +x_17 = lean_ctor_get(x_16, 1); +lean_inc(x_17); +lean_dec(x_16); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_10); +lean_ctor_set(x_18, 1, x_17); +lean_ctor_set(x_6, 0, x_18); +lean_ctor_set(x_14, 0, x_6); +return x_14; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_19 = lean_ctor_get(x_14, 0); +x_20 = lean_ctor_get(x_14, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_14); +x_21 = lean_ctor_get(x_19, 1); +lean_inc(x_21); +lean_dec(x_19); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_10); +lean_ctor_set(x_22, 1, x_21); +lean_ctor_set(x_6, 0, x_22); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_6); +lean_ctor_set(x_23, 1, x_20); +return x_23; +} +} +else +{ +uint8_t x_24; +lean_dec(x_10); +x_24 = !lean_is_exclusive(x_14); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_14, 0); +x_26 = lean_io_error_to_string(x_25); +x_27 = 3; +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_27); +x_29 = lean_array_get_size(x_13); +x_30 = lean_array_push(x_13, x_28); +lean_ctor_set(x_7, 0, x_30); +lean_ctor_set_tag(x_6, 1); +lean_ctor_set(x_6, 0, x_29); +lean_ctor_set_tag(x_14, 0); +lean_ctor_set(x_14, 0, x_6); +return x_14; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_31 = lean_ctor_get(x_14, 0); +x_32 = lean_ctor_get(x_14, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_14); +x_33 = lean_io_error_to_string(x_31); +x_34 = 3; +x_35 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set_uint8(x_35, sizeof(void*)*1, x_34); +x_36 = lean_array_get_size(x_13); +x_37 = lean_array_push(x_13, x_35); +lean_ctor_set(x_7, 0, x_37); +lean_ctor_set_tag(x_6, 1); +lean_ctor_set(x_6, 0, x_36); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_6); +lean_ctor_set(x_38, 1, x_32); +return x_38; +} +} +} +else +{ +lean_object* x_39; uint8_t x_40; lean_object* x_41; +x_39 = lean_ctor_get(x_7, 0); +x_40 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_39); +lean_dec(x_7); +x_41 = lean_io_metadata(x_1, x_8); +lean_dec(x_1); +if (lean_obj_tag(x_41) == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_42 = lean_ctor_get(x_41, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_41, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_44 = x_41; +} else { + lean_dec_ref(x_41); + x_44 = lean_box(0); +} +x_45 = lean_ctor_get(x_42, 1); +lean_inc(x_45); +lean_dec(x_42); +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_39); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_40); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_10); +lean_ctor_set(x_47, 1, x_45); +lean_ctor_set(x_6, 1, x_46); +lean_ctor_set(x_6, 0, x_47); +if (lean_is_scalar(x_44)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_44; +} +lean_ctor_set(x_48, 0, x_6); +lean_ctor_set(x_48, 1, x_43); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_10); +x_49 = lean_ctor_get(x_41, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_41, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_51 = x_41; +} else { + lean_dec_ref(x_41); + x_51 = lean_box(0); +} +x_52 = lean_io_error_to_string(x_49); +x_53 = 3; +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_53); +x_55 = lean_array_get_size(x_39); +x_56 = lean_array_push(x_39, x_54); +x_57 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set_uint8(x_57, sizeof(void*)*1, x_40); +lean_ctor_set_tag(x_6, 1); +lean_ctor_set(x_6, 1, x_57); +lean_ctor_set(x_6, 0, x_55); +if (lean_is_scalar(x_51)) { + x_58 = lean_alloc_ctor(0, 2, 0); +} else { + x_58 = x_51; + lean_ctor_set_tag(x_58, 0); +} +lean_ctor_set(x_58, 0, x_6); +lean_ctor_set(x_58, 1, x_50); +return x_58; +} +} +} +else +{ +lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; +x_59 = lean_ctor_get(x_6, 0); +lean_inc(x_59); +lean_dec(x_6); +x_60 = lean_ctor_get(x_7, 0); +lean_inc(x_60); +x_61 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +if (lean_is_exclusive(x_7)) { + lean_ctor_release(x_7, 0); + x_62 = x_7; +} else { + lean_dec_ref(x_7); + x_62 = lean_box(0); +} +x_63 = lean_io_metadata(x_1, x_8); +lean_dec(x_1); +if (lean_obj_tag(x_63) == 0) +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_64 = lean_ctor_get(x_63, 0); +lean_inc(x_64); +x_65 = lean_ctor_get(x_63, 1); +lean_inc(x_65); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_66 = x_63; +} else { + lean_dec_ref(x_63); + x_66 = lean_box(0); +} +x_67 = lean_ctor_get(x_64, 1); +lean_inc(x_67); +lean_dec(x_64); +if (lean_is_scalar(x_62)) { + x_68 = lean_alloc_ctor(0, 1, 1); +} else { + x_68 = x_62; +} +lean_ctor_set(x_68, 0, x_60); +lean_ctor_set_uint8(x_68, sizeof(void*)*1, x_61); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_59); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_68); +if (lean_is_scalar(x_66)) { + x_71 = lean_alloc_ctor(0, 2, 0); +} else { + x_71 = x_66; +} +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_65); +return x_71; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +lean_dec(x_59); +x_72 = lean_ctor_get(x_63, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_63, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_74 = x_63; +} else { + lean_dec_ref(x_63); + x_74 = lean_box(0); +} +x_75 = lean_io_error_to_string(x_72); +x_76 = 3; +x_77 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_77, 0, x_75); +lean_ctor_set_uint8(x_77, sizeof(void*)*1, x_76); +x_78 = lean_array_get_size(x_60); +x_79 = lean_array_push(x_60, x_77); +if (lean_is_scalar(x_62)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_62; +} +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_61); +x_81 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_81, 0, x_78); +lean_ctor_set(x_81, 1, x_80); +if (lean_is_scalar(x_74)) { + x_82 = lean_alloc_ctor(0, 2, 0); +} else { + x_82 = x_74; + lean_ctor_set_tag(x_82, 0); +} +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_73); +return x_82; +} +} +} +else +{ +uint8_t x_83; +lean_dec(x_1); +x_83 = !lean_is_exclusive(x_5); +if (x_83 == 0) +{ +lean_object* x_84; uint8_t x_85; +x_84 = lean_ctor_get(x_5, 0); +lean_dec(x_84); +x_85 = !lean_is_exclusive(x_6); +if (x_85 == 0) +{ +return x_5; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_86 = lean_ctor_get(x_6, 0); +x_87 = lean_ctor_get(x_6, 1); +lean_inc(x_87); +lean_inc(x_86); +lean_dec(x_6); +x_88 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_88, 0, x_86); +lean_ctor_set(x_88, 1, x_87); +lean_ctor_set(x_5, 0, x_88); +return x_5; +} +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_89 = lean_ctor_get(x_5, 1); +lean_inc(x_89); +lean_dec(x_5); +x_90 = lean_ctor_get(x_6, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_6, 1); +lean_inc(x_91); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + lean_ctor_release(x_6, 1); + x_92 = x_6; +} else { + lean_dec_ref(x_6); + x_92 = lean_box(0); +} +if (lean_is_scalar(x_92)) { + x_93 = lean_alloc_ctor(1, 2, 0); +} else { + x_93 = x_92; +} +lean_ctor_set(x_93, 0, x_90); +lean_ctor_set(x_93, 1, x_91); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_89); +return x_94; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_fetchFileTrace___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_fetchFileTrace(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +lean_inc(x_3); +x_6 = lean_apply_3(x_1, x_3, x_4, x_5); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_6, 1); +lean_inc(x_8); +lean_dec(x_6); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_apply_4(x_2, x_9, x_3, x_10, x_8); +return x_11; +} +else +{ +uint8_t x_12; +lean_dec(x_3); +lean_dec(x_2); +x_12 = !lean_is_exclusive(x_6); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_6, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_7); +if (x_14 == 0) +{ +return x_6; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_7, 0); +x_16 = lean_ctor_get(x_7, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_7); +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_16); +lean_ctor_set(x_6, 0, x_17); +return x_6; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_18 = lean_ctor_get(x_6, 1); +lean_inc(x_18); +lean_dec(x_6); +x_19 = lean_ctor_get(x_7, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_7, 1); +lean_inc(x_20); +if (lean_is_exclusive(x_7)) { + lean_ctor_release(x_7, 0); + lean_ctor_release(x_7, 1); + x_21 = x_7; +} else { + lean_dec_ref(x_7); + x_21 = lean_box(0); +} +if (lean_is_scalar(x_21)) { + x_22 = lean_alloc_ctor(1, 2, 0); +} else { + x_22 = x_21; +} +lean_ctor_set(x_22, 0, x_19); +lean_ctor_set(x_22, 1, x_20); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_18); +return x_23; +} +} +} +else +{ +uint8_t x_24; +lean_dec(x_3); +lean_dec(x_2); +x_24 = !lean_is_exclusive(x_6); +if (x_24 == 0) +{ +return x_6; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_6, 0); +x_26 = lean_ctor_get(x_6, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_6); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +} +} +LEAN_EXPORT lean_object* l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_io_metadata(x_1, x_3); +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_4, 0); +x_7 = lean_ctor_get(x_6, 1); +lean_inc(x_7); +lean_dec(x_6); +x_8 = l_Lake_MTime_instOrd; +x_9 = l_instDecidableRelLt___rarg(x_8, x_2, x_7); +x_10 = lean_box(x_9); +lean_ctor_set(x_4, 0, x_10); +return x_4; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; +x_11 = lean_ctor_get(x_4, 0); +x_12 = lean_ctor_get(x_4, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_4); +x_13 = lean_ctor_get(x_11, 1); +lean_inc(x_13); +lean_dec(x_11); +x_14 = l_Lake_MTime_instOrd; +x_15 = l_instDecidableRelLt___rarg(x_14, x_2, x_13); +x_16 = lean_box(x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_12); +return x_17; +} +} +else +{ +uint8_t x_18; +lean_dec(x_2); +x_18 = !lean_is_exclusive(x_4); +if (x_18 == 0) +{ +lean_object* x_19; uint8_t x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_4, 0); +lean_dec(x_19); +x_20 = 0; +x_21 = lean_box(x_20); +lean_ctor_set_tag(x_4, 0); +lean_ctor_set(x_4, 0, x_21); +return x_4; +} +else +{ +lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_4, 1); +lean_inc(x_22); +lean_dec(x_4); +x_23 = 0; +x_24 = lean_box(x_23); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_22); +return x_25; +} +} +} +} +LEAN_EXPORT uint8_t l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 1; +return x_3; +} +else +{ +uint8_t x_4; +lean_dec(x_2); +x_4 = 0; +return x_4; +} +} +else +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_5; +lean_dec(x_1); +x_5 = 0; +return x_5; +} +else +{ +lean_object* x_6; lean_object* x_7; uint64_t x_8; uint64_t x_9; uint8_t x_10; +x_6 = lean_ctor_get(x_1, 0); +lean_inc(x_6); +lean_dec(x_1); +x_7 = lean_ctor_get(x_2, 0); +lean_inc(x_7); +lean_dec(x_2); +x_8 = lean_unbox_uint64(x_6); +lean_dec(x_6); +x_9 = lean_unbox_uint64(x_7); +lean_dec(x_7); +x_10 = lean_uint64_dec_eq(x_8, x_9); +return x_10; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_2); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_9 = lean_ctor_get(x_2, 0); +x_10 = lean_ctor_get(x_2, 1); +lean_dec(x_10); +x_11 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_11, 0, x_9); +x_12 = l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(x_11, x_3); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_5, 0); +x_14 = lean_ctor_get_uint8(x_13, sizeof(void*)*1); +if (x_14 == 0) +{ +uint8_t x_15; lean_object* x_16; lean_object* x_17; +lean_dec(x_4); +x_15 = 0; +x_16 = lean_box(x_15); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_2); +lean_ctor_set(x_17, 1, x_7); +return x_17; +} +else +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_6); +if (x_18 == 0) +{ +lean_object* x_19; uint8_t x_20; +x_19 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_1, x_4, x_7); +x_20 = !lean_is_exclusive(x_19); +if (x_20 == 0) +{ +lean_object* x_21; +x_21 = lean_ctor_get(x_19, 0); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_21); +lean_ctor_set(x_19, 0, x_2); +return x_19; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_19, 0); +x_23 = lean_ctor_get(x_19, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_19); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_2); +lean_ctor_set(x_24, 1, x_23); +return x_24; +} +} +else +{ +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_25 = lean_ctor_get(x_6, 0); +x_26 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +lean_inc(x_25); +lean_dec(x_6); +x_27 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_1, x_4, x_7); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_27, 1); +lean_inc(x_29); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_30 = x_27; +} else { + lean_dec_ref(x_27); + x_30 = lean_box(0); +} +x_31 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_31, 0, x_25); +lean_ctor_set_uint8(x_31, sizeof(void*)*1, x_26); +lean_ctor_set(x_2, 1, x_31); +lean_ctor_set(x_2, 0, x_28); +if (lean_is_scalar(x_30)) { + x_32 = lean_alloc_ctor(0, 2, 0); +} else { + x_32 = x_30; +} +lean_ctor_set(x_32, 0, x_2); +lean_ctor_set(x_32, 1, x_29); +return x_32; +} +} +} +else +{ +uint8_t x_33; +lean_dec(x_4); +x_33 = !lean_is_exclusive(x_6); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = l_System_FilePath_pathExists(x_1, x_7); +x_35 = !lean_is_exclusive(x_34); +if (x_35 == 0) +{ +lean_object* x_36; +x_36 = lean_ctor_get(x_34, 0); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_36); +lean_ctor_set(x_34, 0, x_2); +return x_34; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_34, 0); +x_38 = lean_ctor_get(x_34, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_34); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_37); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_2); +lean_ctor_set(x_39, 1, x_38); +return x_39; +} +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_40 = lean_ctor_get(x_6, 0); +x_41 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_6); +x_42 = l_System_FilePath_pathExists(x_1, x_7); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_40); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_41); +lean_ctor_set(x_2, 1, x_46); +lean_ctor_set(x_2, 0, x_43); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_2); +lean_ctor_set(x_47, 1, x_44); +return x_47; +} +} +} +else +{ +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_2, 0); +lean_inc(x_48); +lean_dec(x_2); +x_49 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_49, 0, x_48); +x_50 = l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(x_49, x_3); +if (x_50 == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_5, 0); +x_52 = lean_ctor_get_uint8(x_51, sizeof(void*)*1); +if (x_52 == 0) +{ +uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +lean_dec(x_4); +x_53 = 0; +x_54 = lean_box(x_53); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_6); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_7); +return x_56; +} +else +{ +lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_57 = lean_ctor_get(x_6, 0); +lean_inc(x_57); +x_58 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + x_59 = x_6; +} else { + lean_dec_ref(x_6); + x_59 = lean_box(0); +} +x_60 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_1, x_4, x_7); +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_60, 1); +lean_inc(x_62); +if (lean_is_exclusive(x_60)) { + lean_ctor_release(x_60, 0); + lean_ctor_release(x_60, 1); + x_63 = x_60; +} else { + lean_dec_ref(x_60); + x_63 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_64 = lean_alloc_ctor(0, 1, 1); +} else { + x_64 = x_59; +} +lean_ctor_set(x_64, 0, x_57); +lean_ctor_set_uint8(x_64, sizeof(void*)*1, x_58); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_61); +lean_ctor_set(x_65, 1, x_64); +if (lean_is_scalar(x_63)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_63; +} +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_62); +return x_66; +} +} +else +{ +lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_4); +x_67 = lean_ctor_get(x_6, 0); +lean_inc(x_67); +x_68 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + x_69 = x_6; +} else { + lean_dec_ref(x_6); + x_69 = lean_box(0); +} +x_70 = l_System_FilePath_pathExists(x_1, x_7); +x_71 = lean_ctor_get(x_70, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_70, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_70)) { + lean_ctor_release(x_70, 0); + lean_ctor_release(x_70, 1); + x_73 = x_70; +} else { + lean_dec_ref(x_70); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_69)) { + x_74 = lean_alloc_ctor(0, 1, 1); +} else { + x_74 = x_69; +} +lean_ctor_set(x_74, 0, x_67); +lean_ctor_set_uint8(x_74, sizeof(void*)*1, x_68); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_71); +lean_ctor_set(x_75, 1, x_74); +if (lean_is_scalar(x_73)) { + x_76 = lean_alloc_ctor(0, 2, 0); +} else { + x_76 = x_73; +} +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_72); +return x_76; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = lean_usize_dec_eq(x_2, x_3); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +lean_dec(x_4); +x_9 = lean_array_uget(x_1, x_2); +x_10 = !lean_is_exclusive(x_6); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; size_t x_13; size_t x_14; lean_object* x_15; +x_11 = lean_ctor_get(x_6, 0); +x_12 = lean_array_push(x_11, x_9); +lean_ctor_set(x_6, 0, x_12); +x_13 = 1; +x_14 = lean_usize_add(x_2, x_13); +x_15 = lean_box(0); +x_2 = x_14; +x_4 = x_15; +goto _start; +} +else +{ +lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; size_t x_21; size_t x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_6, 0); +x_18 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +lean_inc(x_17); +lean_dec(x_6); +x_19 = lean_array_push(x_17, x_9); +x_20 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set_uint8(x_20, sizeof(void*)*1, x_18); +x_21 = 1; +x_22 = lean_usize_add(x_2, x_21); +x_23 = lean_box(0); +x_2 = x_22; +x_4 = x_23; +x_6 = x_20; +goto _start; +} +} +else +{ +lean_object* x_25; lean_object* x_26; +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_4); +lean_ctor_set(x_25, 1, x_6); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_Lake_clearFileHash(x_1, x_5); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_8, 0); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_4); +lean_ctor_set(x_8, 0, x_11); +return x_8; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_8, 0); +x_13 = lean_ctor_get(x_8, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_8); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_4); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +return x_15; +} +} +else +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_8); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_8, 0); +x_18 = lean_io_error_to_string(x_17); +x_19 = 3; +x_20 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set_uint8(x_20, sizeof(void*)*1, x_19); +x_21 = lean_array_get_size(x_7); +x_22 = lean_array_push(x_7, x_20); +lean_ctor_set(x_4, 0, x_22); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_4); +lean_ctor_set_tag(x_8, 0); +lean_ctor_set(x_8, 0, x_23); +return x_8; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_24 = lean_ctor_get(x_8, 0); +x_25 = lean_ctor_get(x_8, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_8); +x_26 = lean_io_error_to_string(x_24); +x_27 = 3; +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_27); +x_29 = lean_array_get_size(x_7); +x_30 = lean_array_push(x_7, x_28); +lean_ctor_set(x_4, 0, x_30); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_4); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_25); +return x_32; +} +} +} +else +{ +lean_object* x_33; uint8_t x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_4, 0); +x_34 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_33); +lean_dec(x_4); +x_35 = l_Lake_clearFileHash(x_1, x_5); +if (lean_obj_tag(x_35) == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_36 = lean_ctor_get(x_35, 0); +lean_inc(x_36); +x_37 = lean_ctor_get(x_35, 1); +lean_inc(x_37); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_38 = x_35; +} else { + lean_dec_ref(x_35); + x_38 = lean_box(0); +} +x_39 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_39, 0, x_33); +lean_ctor_set_uint8(x_39, sizeof(void*)*1, x_34); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_36); +lean_ctor_set(x_40, 1, x_39); +if (lean_is_scalar(x_38)) { + x_41 = lean_alloc_ctor(0, 2, 0); +} else { + x_41 = x_38; +} +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_37); +return x_41; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_42 = lean_ctor_get(x_35, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_35, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_44 = x_35; +} else { + lean_dec_ref(x_35); + x_44 = lean_box(0); +} +x_45 = lean_io_error_to_string(x_42); +x_46 = 3; +x_47 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set_uint8(x_47, sizeof(void*)*1, x_46); +x_48 = lean_array_get_size(x_33); +x_49 = lean_array_push(x_33, x_47); +x_50 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set_uint8(x_50, sizeof(void*)*1, x_34); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_50); +if (lean_is_scalar(x_44)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_44; + lean_ctor_set_tag(x_52, 0); +} +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_43); +return x_52; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_109; uint8_t x_110; +x_109 = lean_ctor_get(x_7, 0); +lean_inc(x_109); +x_110 = lean_ctor_get_uint8(x_109, sizeof(void*)*1 + 2); +lean_dec(x_109); +if (x_110 == 0) +{ +uint8_t x_111; +x_111 = !lean_is_exclusive(x_8); +if (x_111 == 0) +{ +uint8_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_112 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +x_113 = l_Lake_instOrdJobAction; +x_114 = lean_box(x_112); +x_115 = lean_box(x_5); +x_116 = l_instDecidableRelLe___rarg(x_113, x_114, x_115); +if (x_116 == 0) +{ +lean_object* x_117; lean_object* x_118; +x_117 = lean_box(0); +x_118 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_8); +x_10 = x_118; +x_11 = x_9; +goto block_108; +} +else +{ +lean_object* x_119; lean_object* x_120; +lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_5); +x_119 = lean_box(0); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_8); +x_10 = x_120; +x_11 = x_9; +goto block_108; +} +} +else +{ +lean_object* x_121; uint8_t x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; +x_121 = lean_ctor_get(x_8, 0); +x_122 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_121); +lean_dec(x_8); +x_123 = l_Lake_instOrdJobAction; +x_124 = lean_box(x_122); +x_125 = lean_box(x_5); +x_126 = l_instDecidableRelLe___rarg(x_123, x_124, x_125); +if (x_126 == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_127 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_127, 0, x_121); +lean_ctor_set_uint8(x_127, sizeof(void*)*1, x_122); +x_128 = lean_box(0); +x_129 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set(x_129, 1, x_127); +x_10 = x_129; +x_11 = x_9; +goto block_108; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_130, 0, x_121); +lean_ctor_set_uint8(x_130, sizeof(void*)*1, x_5); +x_131 = lean_box(0); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_130); +x_10 = x_132; +x_11 = x_9; +goto block_108; +} +} +} +else +{ +uint8_t x_133; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_133 = !lean_is_exclusive(x_8); +if (x_133 == 0) +{ +lean_object* x_134; uint8_t x_135; lean_object* x_136; +x_134 = lean_ctor_get(x_8, 0); +x_135 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1; +x_136 = lean_io_exit(x_135, x_9); +if (lean_obj_tag(x_136) == 0) +{ +uint8_t x_137; +x_137 = !lean_is_exclusive(x_136); +if (x_137 == 0) +{ +lean_object* x_138; lean_object* x_139; +x_138 = lean_ctor_get(x_136, 0); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_8); +lean_ctor_set(x_136, 0, x_139); +return x_136; +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_140 = lean_ctor_get(x_136, 0); +x_141 = lean_ctor_get(x_136, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_136); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_140); +lean_ctor_set(x_142, 1, x_8); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_142); +lean_ctor_set(x_143, 1, x_141); +return x_143; +} +} +else +{ +uint8_t x_144; +x_144 = !lean_is_exclusive(x_136); +if (x_144 == 0) +{ +lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_145 = lean_ctor_get(x_136, 0); +x_146 = lean_io_error_to_string(x_145); +x_147 = 3; +x_148 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_148, 0, x_146); +lean_ctor_set_uint8(x_148, sizeof(void*)*1, x_147); +x_149 = lean_array_get_size(x_134); +x_150 = lean_array_push(x_134, x_148); +lean_ctor_set(x_8, 0, x_150); +x_151 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_151, 0, x_149); +lean_ctor_set(x_151, 1, x_8); +lean_ctor_set_tag(x_136, 0); +lean_ctor_set(x_136, 0, x_151); +return x_136; +} +else +{ +lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_152 = lean_ctor_get(x_136, 0); +x_153 = lean_ctor_get(x_136, 1); +lean_inc(x_153); +lean_inc(x_152); +lean_dec(x_136); +x_154 = lean_io_error_to_string(x_152); +x_155 = 3; +x_156 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_156, 0, x_154); +lean_ctor_set_uint8(x_156, sizeof(void*)*1, x_155); +x_157 = lean_array_get_size(x_134); +x_158 = lean_array_push(x_134, x_156); +lean_ctor_set(x_8, 0, x_158); +x_159 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_159, 0, x_157); +lean_ctor_set(x_159, 1, x_8); +x_160 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_153); +return x_160; +} +} +} +else +{ +lean_object* x_161; uint8_t x_162; uint8_t x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_8, 0); +x_162 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_161); +lean_dec(x_8); +x_163 = l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1; +x_164 = lean_io_exit(x_163, x_9); +if (lean_obj_tag(x_164) == 0) +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_165 = lean_ctor_get(x_164, 0); +lean_inc(x_165); +x_166 = lean_ctor_get(x_164, 1); +lean_inc(x_166); +if (lean_is_exclusive(x_164)) { + lean_ctor_release(x_164, 0); + lean_ctor_release(x_164, 1); + x_167 = x_164; +} else { + lean_dec_ref(x_164); + x_167 = lean_box(0); +} +x_168 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_168, 0, x_161); +lean_ctor_set_uint8(x_168, sizeof(void*)*1, x_162); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_165); +lean_ctor_set(x_169, 1, x_168); +if (lean_is_scalar(x_167)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_167; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_166); +return x_170; +} +else +{ +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_171 = lean_ctor_get(x_164, 0); +lean_inc(x_171); +x_172 = lean_ctor_get(x_164, 1); +lean_inc(x_172); +if (lean_is_exclusive(x_164)) { + lean_ctor_release(x_164, 0); + lean_ctor_release(x_164, 1); + x_173 = x_164; +} else { + lean_dec_ref(x_164); + x_173 = lean_box(0); +} +x_174 = lean_io_error_to_string(x_171); +x_175 = 3; +x_176 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_176, 0, x_174); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_175); +x_177 = lean_array_get_size(x_161); +x_178 = lean_array_push(x_161, x_176); +x_179 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_179, 0, x_178); +lean_ctor_set_uint8(x_179, sizeof(void*)*1, x_162); +x_180 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_180, 0, x_177); +lean_ctor_set(x_180, 1, x_179); +if (lean_is_scalar(x_173)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_173; + lean_ctor_set_tag(x_181, 0); +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_172); +return x_181; +} +} +} +block_108: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_array_get_size(x_13); +lean_dec(x_13); +x_15 = l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg(x_1, x_2, x_7, x_12, x_11); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_16); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_18 = lean_ctor_get(x_16, 1); +x_19 = lean_ctor_get(x_16, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 1); +lean_inc(x_20); +lean_dec(x_15); +x_21 = !lean_is_exclusive(x_18); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_18, 0); +x_23 = lean_array_get_size(x_22); +x_24 = l_Array_extract___rarg(x_22, x_14, x_23); +x_25 = l_Lake_writeTraceFile(x_3, x_4, x_24, x_20); +if (lean_obj_tag(x_25) == 0) +{ +uint8_t x_26; +lean_dec(x_23); +x_26 = !lean_is_exclusive(x_25); +if (x_26 == 0) +{ +lean_object* x_27; uint8_t x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_25, 0); +lean_dec(x_27); +x_28 = 0; +x_29 = lean_box(x_28); +lean_ctor_set(x_16, 0, x_29); +lean_ctor_set(x_25, 0, x_16); +return x_25; +} +else +{ +lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_25, 1); +lean_inc(x_30); +lean_dec(x_25); +x_31 = 0; +x_32 = lean_box(x_31); +lean_ctor_set(x_16, 0, x_32); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_16); +lean_ctor_set(x_33, 1, x_30); +return x_33; +} +} +else +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_25); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; +x_35 = lean_ctor_get(x_25, 0); +x_36 = lean_io_error_to_string(x_35); +x_37 = 3; +x_38 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set_uint8(x_38, sizeof(void*)*1, x_37); +x_39 = lean_array_push(x_22, x_38); +lean_ctor_set(x_18, 0, x_39); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 0, x_23); +lean_ctor_set_tag(x_25, 0); +lean_ctor_set(x_25, 0, x_16); +return x_25; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_40 = lean_ctor_get(x_25, 0); +x_41 = lean_ctor_get(x_25, 1); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_25); +x_42 = lean_io_error_to_string(x_40); +x_43 = 3; +x_44 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set_uint8(x_44, sizeof(void*)*1, x_43); +x_45 = lean_array_push(x_22, x_44); +lean_ctor_set(x_18, 0, x_45); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 0, x_23); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_16); +lean_ctor_set(x_46, 1, x_41); +return x_46; +} +} +} +else +{ +lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_47 = lean_ctor_get(x_18, 0); +x_48 = lean_ctor_get_uint8(x_18, sizeof(void*)*1); +lean_inc(x_47); +lean_dec(x_18); +x_49 = lean_array_get_size(x_47); +x_50 = l_Array_extract___rarg(x_47, x_14, x_49); +x_51 = l_Lake_writeTraceFile(x_3, x_4, x_50, x_20); +if (lean_obj_tag(x_51) == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; +lean_dec(x_49); +x_52 = lean_ctor_get(x_51, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_53 = x_51; +} else { + lean_dec_ref(x_51); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_47); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_48); +x_55 = 0; +x_56 = lean_box(x_55); +lean_ctor_set(x_16, 1, x_54); +lean_ctor_set(x_16, 0, x_56); +if (lean_is_scalar(x_53)) { + x_57 = lean_alloc_ctor(0, 2, 0); +} else { + x_57 = x_53; +} +lean_ctor_set(x_57, 0, x_16); +lean_ctor_set(x_57, 1, x_52); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_58 = lean_ctor_get(x_51, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_51, 1); +lean_inc(x_59); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_60 = x_51; +} else { + lean_dec_ref(x_51); + x_60 = lean_box(0); +} +x_61 = lean_io_error_to_string(x_58); +x_62 = 3; +x_63 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set_uint8(x_63, sizeof(void*)*1, x_62); +x_64 = lean_array_push(x_47, x_63); +x_65 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set_uint8(x_65, sizeof(void*)*1, x_48); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 1, x_65); +lean_ctor_set(x_16, 0, x_49); +if (lean_is_scalar(x_60)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_60; + lean_ctor_set_tag(x_66, 0); +} +lean_ctor_set(x_66, 0, x_16); +lean_ctor_set(x_66, 1, x_59); +return x_66; +} +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_67 = lean_ctor_get(x_16, 1); +lean_inc(x_67); +lean_dec(x_16); +x_68 = lean_ctor_get(x_15, 1); +lean_inc(x_68); +lean_dec(x_15); +x_69 = lean_ctor_get(x_67, 0); +lean_inc(x_69); +x_70 = lean_ctor_get_uint8(x_67, sizeof(void*)*1); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + x_71 = x_67; +} else { + lean_dec_ref(x_67); + x_71 = lean_box(0); +} +x_72 = lean_array_get_size(x_69); +x_73 = l_Array_extract___rarg(x_69, x_14, x_72); +x_74 = l_Lake_writeTraceFile(x_3, x_4, x_73, x_68); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_dec(x_72); +x_75 = lean_ctor_get(x_74, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_74)) { + lean_ctor_release(x_74, 0); + lean_ctor_release(x_74, 1); + x_76 = x_74; +} else { + lean_dec_ref(x_74); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_71)) { + x_77 = lean_alloc_ctor(0, 1, 1); +} else { + x_77 = x_71; +} +lean_ctor_set(x_77, 0, x_69); +lean_ctor_set_uint8(x_77, sizeof(void*)*1, x_70); +x_78 = 0; +x_79 = lean_box(x_78); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_77); +if (lean_is_scalar(x_76)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_76; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_75); +return x_81; +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_82 = lean_ctor_get(x_74, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_74, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_74)) { + lean_ctor_release(x_74, 0); + lean_ctor_release(x_74, 1); + x_84 = x_74; +} else { + lean_dec_ref(x_74); + x_84 = lean_box(0); +} +x_85 = lean_io_error_to_string(x_82); +x_86 = 3; +x_87 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set_uint8(x_87, sizeof(void*)*1, x_86); +x_88 = lean_array_push(x_69, x_87); +if (lean_is_scalar(x_71)) { + x_89 = lean_alloc_ctor(0, 1, 1); +} else { + x_89 = x_71; +} +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set_uint8(x_89, sizeof(void*)*1, x_70); +x_90 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_90, 0, x_72); +lean_ctor_set(x_90, 1, x_89); +if (lean_is_scalar(x_84)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_84; + lean_ctor_set_tag(x_91, 0); +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_83); +return x_91; +} +} +} +else +{ +uint8_t x_92; +lean_dec(x_14); +lean_dec(x_4); +lean_dec(x_3); +x_92 = !lean_is_exclusive(x_15); +if (x_92 == 0) +{ +lean_object* x_93; uint8_t x_94; +x_93 = lean_ctor_get(x_15, 0); +lean_dec(x_93); +x_94 = !lean_is_exclusive(x_16); +if (x_94 == 0) +{ +return x_15; +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_95 = lean_ctor_get(x_16, 0); +x_96 = lean_ctor_get(x_16, 1); +lean_inc(x_96); +lean_inc(x_95); +lean_dec(x_16); +x_97 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_97, 0, x_95); +lean_ctor_set(x_97, 1, x_96); +lean_ctor_set(x_15, 0, x_97); +return x_15; +} +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_98 = lean_ctor_get(x_15, 1); +lean_inc(x_98); +lean_dec(x_15); +x_99 = lean_ctor_get(x_16, 0); +lean_inc(x_99); +x_100 = lean_ctor_get(x_16, 1); +lean_inc(x_100); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_101 = x_16; +} else { + lean_dec_ref(x_16); + x_101 = lean_box(0); +} +if (lean_is_scalar(x_101)) { + x_102 = lean_alloc_ctor(1, 2, 0); +} else { + x_102 = x_101; +} +lean_ctor_set(x_102, 0, x_99); +lean_ctor_set(x_102, 1, x_100); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_98); +return x_103; +} +} +} +else +{ +uint8_t x_104; +lean_dec(x_14); +lean_dec(x_4); +lean_dec(x_3); +x_104 = !lean_is_exclusive(x_15); +if (x_104 == 0) +{ +return x_15; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_105 = lean_ctor_get(x_15, 0); +x_106 = lean_ctor_get(x_15, 1); +lean_inc(x_106); +lean_inc(x_105); +lean_dec(x_15); +x_107 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_107, 0, x_105); +lean_ctor_set(x_107, 1, x_106); +return x_107; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_328; +x_11 = lean_alloc_closure((void*)(l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__1___boxed), 5, 1); +lean_closure_set(x_11, 0, x_1); +x_328 = !lean_is_exclusive(x_9); +if (x_328 == 0) +{ +lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; uint8_t x_333; +x_329 = lean_ctor_get(x_9, 0); +x_330 = l_Lake_readTraceFile_x3f(x_5, x_329, x_10); +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 = !lean_is_exclusive(x_331); +if (x_333 == 0) +{ +lean_object* x_334; +x_334 = lean_ctor_get(x_331, 1); +lean_ctor_set(x_9, 0, x_334); +lean_ctor_set(x_331, 1, x_9); +x_12 = x_331; +x_13 = x_332; +goto block_327; +} +else +{ +lean_object* x_335; lean_object* x_336; lean_object* x_337; +x_335 = lean_ctor_get(x_331, 0); +x_336 = lean_ctor_get(x_331, 1); +lean_inc(x_336); +lean_inc(x_335); +lean_dec(x_331); +lean_ctor_set(x_9, 0, x_336); +x_337 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_337, 0, x_335); +lean_ctor_set(x_337, 1, x_9); +x_12 = x_337; +x_13 = x_332; +goto block_327; +} +} +else +{ +lean_object* x_338; uint8_t 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; +x_338 = lean_ctor_get(x_9, 0); +x_339 = lean_ctor_get_uint8(x_9, sizeof(void*)*1); +lean_inc(x_338); +lean_dec(x_9); +x_340 = l_Lake_readTraceFile_x3f(x_5, x_338, x_10); +x_341 = lean_ctor_get(x_340, 0); +lean_inc(x_341); +x_342 = lean_ctor_get(x_340, 1); +lean_inc(x_342); +lean_dec(x_340); +x_343 = lean_ctor_get(x_341, 0); +lean_inc(x_343); +x_344 = lean_ctor_get(x_341, 1); +lean_inc(x_344); +if (lean_is_exclusive(x_341)) { + lean_ctor_release(x_341, 0); + lean_ctor_release(x_341, 1); + x_345 = x_341; +} else { + lean_dec_ref(x_341); + x_345 = lean_box(0); +} +x_346 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_346, 0, x_344); +lean_ctor_set_uint8(x_346, sizeof(void*)*1, x_339); +if (lean_is_scalar(x_345)) { + x_347 = lean_alloc_ctor(0, 2, 0); +} else { + x_347 = x_345; +} +lean_ctor_set(x_347, 0, x_343); +lean_ctor_set(x_347, 1, x_346); +x_12 = x_347; +x_13 = x_342; +goto block_327; +} +block_327: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_8, 0); +lean_inc(x_15); +x_16 = lean_ctor_get_uint8(x_15, sizeof(void*)*1); +lean_dec(x_15); +if (x_16 == 0) +{ +uint8_t x_17; +lean_dec(x_7); +x_17 = !lean_is_exclusive(x_12); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_18 = lean_ctor_get(x_12, 1); +x_19 = lean_ctor_get(x_12, 0); +lean_dec(x_19); +x_20 = !lean_is_exclusive(x_18); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; uint8_t x_23; +x_21 = lean_ctor_get(x_4, 1); +lean_inc(x_21); +x_22 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_3, x_21, x_13); +x_23 = !lean_is_exclusive(x_22); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; uint8_t x_26; +x_24 = lean_ctor_get(x_22, 0); +x_25 = lean_ctor_get(x_22, 1); +x_26 = lean_unbox(x_24); +lean_dec(x_24); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; +lean_free_object(x_22); +lean_free_object(x_12); +x_27 = lean_box(0); +x_28 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_27, x_8, x_18, x_25); +return x_28; +} +else +{ +uint8_t x_29; lean_object* x_30; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_29 = 1; +x_30 = lean_box(x_29); +lean_ctor_set(x_12, 0, x_30); +lean_ctor_set(x_22, 0, x_12); +return x_22; +} +} +else +{ +lean_object* x_31; lean_object* x_32; uint8_t x_33; +x_31 = lean_ctor_get(x_22, 0); +x_32 = lean_ctor_get(x_22, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_22); +x_33 = lean_unbox(x_31); +lean_dec(x_31); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; +lean_free_object(x_12); +x_34 = lean_box(0); +x_35 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_34, x_8, x_18, x_32); +return x_35; +} +else +{ +uint8_t x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_36 = 1; +x_37 = lean_box(x_36); +lean_ctor_set(x_12, 0, x_37); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_12); +lean_ctor_set(x_38, 1, x_32); +return x_38; +} +} +} +else +{ +lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; +x_39 = lean_ctor_get(x_18, 0); +x_40 = lean_ctor_get_uint8(x_18, sizeof(void*)*1); +lean_inc(x_39); +lean_dec(x_18); +x_41 = lean_ctor_get(x_4, 1); +lean_inc(x_41); +x_42 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_3, x_41, x_13); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_39); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_40); +x_47 = lean_unbox(x_43); +lean_dec(x_43); +if (x_47 == 0) +{ +lean_object* x_48; lean_object* x_49; +lean_dec(x_45); +lean_free_object(x_12); +x_48 = lean_box(0); +x_49 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_48, x_8, x_46, x_44); +return x_49; +} +else +{ +uint8_t x_50; lean_object* x_51; lean_object* x_52; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_50 = 1; +x_51 = lean_box(x_50); +lean_ctor_set(x_12, 1, x_46); +lean_ctor_set(x_12, 0, x_51); +if (lean_is_scalar(x_45)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_45; +} +lean_ctor_set(x_52, 0, x_12); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; +x_53 = lean_ctor_get(x_12, 1); +lean_inc(x_53); +lean_dec(x_12); +x_54 = lean_ctor_get(x_53, 0); +lean_inc(x_54); +x_55 = lean_ctor_get_uint8(x_53, sizeof(void*)*1); +if (lean_is_exclusive(x_53)) { + lean_ctor_release(x_53, 0); + x_56 = x_53; +} else { + lean_dec_ref(x_53); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_4, 1); +lean_inc(x_57); +x_58 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_3, x_57, x_13); +x_59 = lean_ctor_get(x_58, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_58, 1); +lean_inc(x_60); +if (lean_is_exclusive(x_58)) { + lean_ctor_release(x_58, 0); + lean_ctor_release(x_58, 1); + x_61 = x_58; +} else { + lean_dec_ref(x_58); + x_61 = lean_box(0); +} +if (lean_is_scalar(x_56)) { + x_62 = lean_alloc_ctor(0, 1, 1); +} else { + x_62 = x_56; +} +lean_ctor_set(x_62, 0, x_54); +lean_ctor_set_uint8(x_62, sizeof(void*)*1, x_55); +x_63 = lean_unbox(x_59); +lean_dec(x_59); +if (x_63 == 0) +{ +lean_object* x_64; lean_object* x_65; +lean_dec(x_61); +x_64 = lean_box(0); +x_65 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_64, x_8, x_62, x_60); +return x_65; +} +else +{ +uint8_t x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_66 = 1; +x_67 = lean_box(x_66); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_67); +lean_ctor_set(x_68, 1, x_62); +if (lean_is_scalar(x_61)) { + x_69 = lean_alloc_ctor(0, 2, 0); +} else { + x_69 = x_61; +} +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_60); +return x_69; +} +} +} +else +{ +uint8_t x_70; +x_70 = !lean_is_exclusive(x_12); +if (x_70 == 0) +{ +lean_object* x_71; lean_object* x_72; uint8_t x_73; +x_71 = lean_ctor_get(x_12, 1); +x_72 = lean_ctor_get(x_12, 0); +lean_dec(x_72); +x_73 = !lean_is_exclusive(x_71); +if (x_73 == 0) +{ +lean_object* x_74; uint8_t x_75; +x_74 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_3, x_7, x_13); +x_75 = !lean_is_exclusive(x_74); +if (x_75 == 0) +{ +lean_object* x_76; lean_object* x_77; uint8_t x_78; +x_76 = lean_ctor_get(x_74, 0); +x_77 = lean_ctor_get(x_74, 1); +x_78 = lean_unbox(x_76); +lean_dec(x_76); +if (x_78 == 0) +{ +lean_object* x_79; lean_object* x_80; +lean_free_object(x_74); +lean_free_object(x_12); +x_79 = lean_box(0); +x_80 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_79, x_8, x_71, x_77); +return x_80; +} +else +{ +uint8_t x_81; lean_object* x_82; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_81 = 1; +x_82 = lean_box(x_81); +lean_ctor_set(x_12, 0, x_82); +lean_ctor_set(x_74, 0, x_12); +return x_74; +} +} +else +{ +lean_object* x_83; lean_object* x_84; uint8_t x_85; +x_83 = lean_ctor_get(x_74, 0); +x_84 = lean_ctor_get(x_74, 1); +lean_inc(x_84); +lean_inc(x_83); +lean_dec(x_74); +x_85 = lean_unbox(x_83); +lean_dec(x_83); +if (x_85 == 0) +{ +lean_object* x_86; lean_object* x_87; +lean_free_object(x_12); +x_86 = lean_box(0); +x_87 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_86, x_8, x_71, x_84); +return x_87; +} +else +{ +uint8_t x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_88 = 1; +x_89 = lean_box(x_88); +lean_ctor_set(x_12, 0, x_89); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_12); +lean_ctor_set(x_90, 1, x_84); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; +x_91 = lean_ctor_get(x_71, 0); +x_92 = lean_ctor_get_uint8(x_71, sizeof(void*)*1); +lean_inc(x_91); +lean_dec(x_71); +x_93 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_3, x_7, x_13); +x_94 = lean_ctor_get(x_93, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_93, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_93)) { + lean_ctor_release(x_93, 0); + lean_ctor_release(x_93, 1); + x_96 = x_93; +} else { + lean_dec_ref(x_93); + x_96 = lean_box(0); +} +x_97 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_97, 0, x_91); +lean_ctor_set_uint8(x_97, sizeof(void*)*1, x_92); +x_98 = lean_unbox(x_94); +lean_dec(x_94); +if (x_98 == 0) +{ +lean_object* x_99; lean_object* x_100; +lean_dec(x_96); +lean_free_object(x_12); +x_99 = lean_box(0); +x_100 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_99, x_8, x_97, x_95); +return x_100; +} +else +{ +uint8_t x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_101 = 1; +x_102 = lean_box(x_101); +lean_ctor_set(x_12, 1, x_97); +lean_ctor_set(x_12, 0, x_102); +if (lean_is_scalar(x_96)) { + x_103 = lean_alloc_ctor(0, 2, 0); +} else { + x_103 = x_96; +} +lean_ctor_set(x_103, 0, x_12); +lean_ctor_set(x_103, 1, x_95); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; +x_104 = lean_ctor_get(x_12, 1); +lean_inc(x_104); +lean_dec(x_12); +x_105 = lean_ctor_get(x_104, 0); +lean_inc(x_105); +x_106 = lean_ctor_get_uint8(x_104, sizeof(void*)*1); +if (lean_is_exclusive(x_104)) { + lean_ctor_release(x_104, 0); + x_107 = x_104; +} else { + lean_dec_ref(x_104); + x_107 = lean_box(0); +} +x_108 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_3, x_7, x_13); +x_109 = lean_ctor_get(x_108, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_108, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_108)) { + lean_ctor_release(x_108, 0); + lean_ctor_release(x_108, 1); + x_111 = x_108; +} else { + lean_dec_ref(x_108); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_112 = lean_alloc_ctor(0, 1, 1); +} else { + x_112 = x_107; +} +lean_ctor_set(x_112, 0, x_105); +lean_ctor_set_uint8(x_112, sizeof(void*)*1, x_106); +x_113 = lean_unbox(x_109); +lean_dec(x_109); +if (x_113 == 0) +{ +lean_object* x_114; lean_object* x_115; +lean_dec(x_111); +x_114 = lean_box(0); +x_115 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_114, x_8, x_112, x_110); +return x_115; +} +else +{ +uint8_t x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_116 = 1; +x_117 = lean_box(x_116); +x_118 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_112); +if (lean_is_scalar(x_111)) { + x_119 = lean_alloc_ctor(0, 2, 0); +} else { + x_119 = x_111; +} +lean_ctor_set(x_119, 0, x_118); +lean_ctor_set(x_119, 1, x_110); +return x_119; +} +} +} +} +else +{ +uint8_t x_120; +x_120 = !lean_is_exclusive(x_14); +if (x_120 == 0) +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; +x_121 = lean_ctor_get(x_14, 0); +x_122 = lean_ctor_get(x_12, 1); +lean_inc(x_122); +lean_dec(x_12); +x_123 = lean_ctor_get(x_121, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_121, 1); +lean_inc(x_124); +lean_dec(x_121); +lean_ctor_set(x_14, 0, x_123); +lean_inc(x_4); +x_125 = l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(x_3, x_4, x_14, x_7, x_8, x_122, x_13); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +x_127 = lean_ctor_get(x_125, 1); +lean_inc(x_127); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + lean_ctor_release(x_125, 1); + x_128 = x_125; +} else { + lean_dec_ref(x_125); + x_128 = lean_box(0); +} +x_129 = !lean_is_exclusive(x_126); +if (x_129 == 0) +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_196; +x_130 = lean_ctor_get(x_126, 0); +x_131 = lean_ctor_get(x_126, 1); +x_196 = lean_unbox(x_130); +lean_dec(x_130); +if (x_196 == 0) +{ +lean_object* x_197; lean_object* x_198; +lean_free_object(x_126); +lean_dec(x_128); +lean_dec(x_124); +x_197 = lean_box(0); +x_198 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_197, x_8, x_131, x_127); +return x_198; +} +else +{ +uint8_t x_199; +lean_dec(x_11); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_199 = !lean_is_exclusive(x_131); +if (x_199 == 0) +{ +uint8_t x_200; lean_object* x_201; uint8_t x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; +x_200 = lean_ctor_get_uint8(x_131, sizeof(void*)*1); +x_201 = l_Lake_instOrdJobAction; +x_202 = 1; +x_203 = lean_box(x_200); +x_204 = lean_box(x_202); +x_205 = l_instDecidableRelLe___rarg(x_201, x_203, x_204); +if (x_205 == 0) +{ +lean_object* x_206; +x_206 = lean_box(0); +lean_ctor_set(x_126, 0, x_206); +x_132 = x_126; +x_133 = x_127; +goto block_195; +} +else +{ +lean_object* x_207; +lean_ctor_set_uint8(x_131, sizeof(void*)*1, x_202); +x_207 = lean_box(0); +lean_ctor_set(x_126, 0, x_207); +x_132 = x_126; +x_133 = x_127; +goto block_195; +} +} +else +{ +lean_object* x_208; uint8_t x_209; lean_object* x_210; uint8_t x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; +x_208 = lean_ctor_get(x_131, 0); +x_209 = lean_ctor_get_uint8(x_131, sizeof(void*)*1); +lean_inc(x_208); +lean_dec(x_131); +x_210 = l_Lake_instOrdJobAction; +x_211 = 1; +x_212 = lean_box(x_209); +x_213 = lean_box(x_211); +x_214 = l_instDecidableRelLe___rarg(x_210, x_212, x_213); +if (x_214 == 0) +{ +lean_object* x_215; lean_object* x_216; +x_215 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_215, 0, x_208); +lean_ctor_set_uint8(x_215, sizeof(void*)*1, x_209); +x_216 = lean_box(0); +lean_ctor_set(x_126, 1, x_215); +lean_ctor_set(x_126, 0, x_216); +x_132 = x_126; +x_133 = x_127; +goto block_195; +} +else +{ +lean_object* x_217; lean_object* x_218; +x_217 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_217, 0, x_208); +lean_ctor_set_uint8(x_217, sizeof(void*)*1, x_211); +x_218 = lean_box(0); +lean_ctor_set(x_126, 1, x_217); +lean_ctor_set(x_126, 0, x_218); +x_132 = x_126; +x_133 = x_127; +goto block_195; +} +} +} +block_195: +{ +uint8_t x_134; +x_134 = !lean_is_exclusive(x_132); +if (x_134 == 0) +{ +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; +x_135 = lean_ctor_get(x_132, 1); +x_136 = lean_ctor_get(x_132, 0); +lean_dec(x_136); +x_137 = lean_array_get_size(x_124); +x_138 = lean_unsigned_to_nat(0u); +x_139 = lean_nat_dec_lt(x_138, x_137); +if (x_139 == 0) +{ +uint8_t x_140; lean_object* x_141; lean_object* x_142; +lean_dec(x_137); +lean_dec(x_124); +lean_dec(x_8); +x_140 = 1; +x_141 = lean_box(x_140); +lean_ctor_set(x_132, 0, x_141); +if (lean_is_scalar(x_128)) { + x_142 = lean_alloc_ctor(0, 2, 0); +} else { + x_142 = x_128; +} +lean_ctor_set(x_142, 0, x_132); +lean_ctor_set(x_142, 1, x_133); +return x_142; +} +else +{ +uint8_t x_143; +x_143 = lean_nat_dec_le(x_137, x_137); +if (x_143 == 0) +{ +uint8_t x_144; lean_object* x_145; lean_object* x_146; +lean_dec(x_137); +lean_dec(x_124); +lean_dec(x_8); +x_144 = 1; +x_145 = lean_box(x_144); +lean_ctor_set(x_132, 0, x_145); +if (lean_is_scalar(x_128)) { + x_146 = lean_alloc_ctor(0, 2, 0); +} else { + x_146 = x_128; +} +lean_ctor_set(x_146, 0, x_132); +lean_ctor_set(x_146, 1, x_133); +return x_146; +} +else +{ +size_t x_147; size_t x_148; lean_object* x_149; lean_object* x_150; uint8_t x_151; +lean_free_object(x_132); +lean_dec(x_128); +x_147 = 0; +x_148 = lean_usize_of_nat(x_137); +lean_dec(x_137); +x_149 = lean_box(0); +x_150 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_124, x_147, x_148, x_149, x_8, x_135, x_133); +lean_dec(x_8); +lean_dec(x_124); +x_151 = !lean_is_exclusive(x_150); +if (x_151 == 0) +{ +lean_object* x_152; uint8_t x_153; +x_152 = lean_ctor_get(x_150, 0); +x_153 = !lean_is_exclusive(x_152); +if (x_153 == 0) +{ +lean_object* x_154; uint8_t x_155; lean_object* x_156; +x_154 = lean_ctor_get(x_152, 0); +lean_dec(x_154); +x_155 = 1; +x_156 = lean_box(x_155); +lean_ctor_set(x_152, 0, x_156); +return x_150; +} +else +{ +lean_object* x_157; uint8_t x_158; lean_object* x_159; lean_object* x_160; +x_157 = lean_ctor_get(x_152, 1); +lean_inc(x_157); +lean_dec(x_152); +x_158 = 1; +x_159 = lean_box(x_158); +x_160 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_157); +lean_ctor_set(x_150, 0, x_160); +return x_150; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; +x_161 = lean_ctor_get(x_150, 0); +x_162 = lean_ctor_get(x_150, 1); +lean_inc(x_162); +lean_inc(x_161); +lean_dec(x_150); +x_163 = lean_ctor_get(x_161, 1); +lean_inc(x_163); +if (lean_is_exclusive(x_161)) { + lean_ctor_release(x_161, 0); + lean_ctor_release(x_161, 1); + x_164 = x_161; +} else { + lean_dec_ref(x_161); + x_164 = lean_box(0); +} +x_165 = 1; +x_166 = lean_box(x_165); +if (lean_is_scalar(x_164)) { + x_167 = lean_alloc_ctor(0, 2, 0); +} else { + x_167 = x_164; +} +lean_ctor_set(x_167, 0, x_166); +lean_ctor_set(x_167, 1, x_163); +x_168 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_168, 0, x_167); +lean_ctor_set(x_168, 1, x_162); +return x_168; +} +} +} +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; +x_169 = lean_ctor_get(x_132, 1); +lean_inc(x_169); +lean_dec(x_132); +x_170 = lean_array_get_size(x_124); +x_171 = lean_unsigned_to_nat(0u); +x_172 = lean_nat_dec_lt(x_171, x_170); +if (x_172 == 0) +{ +uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; +lean_dec(x_170); +lean_dec(x_124); +lean_dec(x_8); +x_173 = 1; +x_174 = lean_box(x_173); +x_175 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_175, 0, x_174); +lean_ctor_set(x_175, 1, x_169); +if (lean_is_scalar(x_128)) { + x_176 = lean_alloc_ctor(0, 2, 0); +} else { + x_176 = x_128; +} +lean_ctor_set(x_176, 0, x_175); +lean_ctor_set(x_176, 1, x_133); +return x_176; +} +else +{ +uint8_t x_177; +x_177 = lean_nat_dec_le(x_170, x_170); +if (x_177 == 0) +{ +uint8_t x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +lean_dec(x_170); +lean_dec(x_124); +lean_dec(x_8); +x_178 = 1; +x_179 = lean_box(x_178); +x_180 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_169); +if (lean_is_scalar(x_128)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_128; +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_133); +return x_181; +} +else +{ +size_t x_182; size_t x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; +lean_dec(x_128); +x_182 = 0; +x_183 = lean_usize_of_nat(x_170); +lean_dec(x_170); +x_184 = lean_box(0); +x_185 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_124, x_182, x_183, x_184, x_8, x_169, x_133); +lean_dec(x_8); +lean_dec(x_124); +x_186 = lean_ctor_get(x_185, 0); +lean_inc(x_186); +x_187 = lean_ctor_get(x_185, 1); +lean_inc(x_187); +if (lean_is_exclusive(x_185)) { + lean_ctor_release(x_185, 0); + lean_ctor_release(x_185, 1); + x_188 = x_185; +} else { + lean_dec_ref(x_185); + x_188 = lean_box(0); +} +x_189 = lean_ctor_get(x_186, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_186)) { + lean_ctor_release(x_186, 0); + lean_ctor_release(x_186, 1); + x_190 = x_186; +} else { + lean_dec_ref(x_186); + x_190 = lean_box(0); +} +x_191 = 1; +x_192 = lean_box(x_191); +if (lean_is_scalar(x_190)) { + x_193 = lean_alloc_ctor(0, 2, 0); +} else { + x_193 = x_190; +} +lean_ctor_set(x_193, 0, x_192); +lean_ctor_set(x_193, 1, x_189); +if (lean_is_scalar(x_188)) { + x_194 = lean_alloc_ctor(0, 2, 0); +} else { + x_194 = x_188; +} +lean_ctor_set(x_194, 0, x_193); +lean_ctor_set(x_194, 1, x_187); +return x_194; +} +} +} +} +} +else +{ +lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; uint8_t x_251; +x_219 = lean_ctor_get(x_126, 0); +x_220 = lean_ctor_get(x_126, 1); +lean_inc(x_220); +lean_inc(x_219); +lean_dec(x_126); +x_251 = lean_unbox(x_219); +lean_dec(x_219); +if (x_251 == 0) +{ +lean_object* x_252; lean_object* x_253; +lean_dec(x_128); +lean_dec(x_124); +x_252 = lean_box(0); +x_253 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_252, x_8, x_220, x_127); +return x_253; +} +else +{ +lean_object* x_254; uint8_t x_255; lean_object* x_256; lean_object* x_257; uint8_t x_258; lean_object* x_259; lean_object* x_260; uint8_t x_261; +lean_dec(x_11); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_254 = lean_ctor_get(x_220, 0); +lean_inc(x_254); +x_255 = lean_ctor_get_uint8(x_220, sizeof(void*)*1); +if (lean_is_exclusive(x_220)) { + lean_ctor_release(x_220, 0); + x_256 = x_220; +} else { + lean_dec_ref(x_220); + x_256 = lean_box(0); +} +x_257 = l_Lake_instOrdJobAction; +x_258 = 1; +x_259 = lean_box(x_255); +x_260 = lean_box(x_258); +x_261 = l_instDecidableRelLe___rarg(x_257, x_259, x_260); +if (x_261 == 0) +{ +lean_object* x_262; lean_object* x_263; lean_object* x_264; +if (lean_is_scalar(x_256)) { + x_262 = lean_alloc_ctor(0, 1, 1); +} else { + x_262 = x_256; +} +lean_ctor_set(x_262, 0, x_254); +lean_ctor_set_uint8(x_262, sizeof(void*)*1, x_255); +x_263 = lean_box(0); +x_264 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_262); +x_221 = x_264; +x_222 = x_127; +goto block_250; +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; +if (lean_is_scalar(x_256)) { + x_265 = lean_alloc_ctor(0, 1, 1); +} else { + x_265 = x_256; +} +lean_ctor_set(x_265, 0, x_254); +lean_ctor_set_uint8(x_265, sizeof(void*)*1, x_258); +x_266 = lean_box(0); +x_267 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_267, 0, x_266); +lean_ctor_set(x_267, 1, x_265); +x_221 = x_267; +x_222 = x_127; +goto block_250; +} +} +block_250: +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; uint8_t x_227; +x_223 = lean_ctor_get(x_221, 1); +lean_inc(x_223); +if (lean_is_exclusive(x_221)) { + lean_ctor_release(x_221, 0); + lean_ctor_release(x_221, 1); + x_224 = x_221; +} else { + lean_dec_ref(x_221); + x_224 = lean_box(0); +} +x_225 = lean_array_get_size(x_124); +x_226 = lean_unsigned_to_nat(0u); +x_227 = lean_nat_dec_lt(x_226, x_225); +if (x_227 == 0) +{ +uint8_t x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; +lean_dec(x_225); +lean_dec(x_124); +lean_dec(x_8); +x_228 = 1; +x_229 = lean_box(x_228); +if (lean_is_scalar(x_224)) { + x_230 = lean_alloc_ctor(0, 2, 0); +} else { + x_230 = x_224; +} +lean_ctor_set(x_230, 0, x_229); +lean_ctor_set(x_230, 1, x_223); +if (lean_is_scalar(x_128)) { + x_231 = lean_alloc_ctor(0, 2, 0); +} else { + x_231 = x_128; +} +lean_ctor_set(x_231, 0, x_230); +lean_ctor_set(x_231, 1, x_222); +return x_231; +} +else +{ +uint8_t x_232; +x_232 = lean_nat_dec_le(x_225, x_225); +if (x_232 == 0) +{ +uint8_t x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; +lean_dec(x_225); +lean_dec(x_124); +lean_dec(x_8); +x_233 = 1; +x_234 = lean_box(x_233); +if (lean_is_scalar(x_224)) { + x_235 = lean_alloc_ctor(0, 2, 0); +} else { + x_235 = x_224; +} +lean_ctor_set(x_235, 0, x_234); +lean_ctor_set(x_235, 1, x_223); +if (lean_is_scalar(x_128)) { + x_236 = lean_alloc_ctor(0, 2, 0); +} else { + x_236 = x_128; +} +lean_ctor_set(x_236, 0, x_235); +lean_ctor_set(x_236, 1, x_222); +return x_236; +} +else +{ +size_t x_237; size_t x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_224); +lean_dec(x_128); +x_237 = 0; +x_238 = lean_usize_of_nat(x_225); +lean_dec(x_225); +x_239 = lean_box(0); +x_240 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_124, x_237, x_238, x_239, x_8, x_223, x_222); +lean_dec(x_8); +lean_dec(x_124); +x_241 = lean_ctor_get(x_240, 0); +lean_inc(x_241); +x_242 = lean_ctor_get(x_240, 1); +lean_inc(x_242); +if (lean_is_exclusive(x_240)) { + lean_ctor_release(x_240, 0); + lean_ctor_release(x_240, 1); + x_243 = x_240; +} else { + lean_dec_ref(x_240); + x_243 = lean_box(0); +} +x_244 = lean_ctor_get(x_241, 1); +lean_inc(x_244); +if (lean_is_exclusive(x_241)) { + lean_ctor_release(x_241, 0); + lean_ctor_release(x_241, 1); + x_245 = x_241; +} else { + lean_dec_ref(x_241); + x_245 = lean_box(0); +} +x_246 = 1; +x_247 = lean_box(x_246); +if (lean_is_scalar(x_245)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_245; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_244); +if (lean_is_scalar(x_243)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_243; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_242); +return x_249; +} +} +} +} +} +else +{ +lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; uint8_t x_310; +x_268 = lean_ctor_get(x_14, 0); +lean_inc(x_268); +lean_dec(x_14); +x_269 = lean_ctor_get(x_12, 1); +lean_inc(x_269); +lean_dec(x_12); +x_270 = lean_ctor_get(x_268, 0); +lean_inc(x_270); +x_271 = lean_ctor_get(x_268, 1); +lean_inc(x_271); +lean_dec(x_268); +x_272 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_272, 0, x_270); +lean_inc(x_4); +x_273 = l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(x_3, x_4, x_272, x_7, x_8, x_269, x_13); +x_274 = lean_ctor_get(x_273, 0); +lean_inc(x_274); +x_275 = lean_ctor_get(x_273, 1); +lean_inc(x_275); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + lean_ctor_release(x_273, 1); + x_276 = x_273; +} else { + lean_dec_ref(x_273); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_274, 0); +lean_inc(x_277); +x_278 = lean_ctor_get(x_274, 1); +lean_inc(x_278); +if (lean_is_exclusive(x_274)) { + lean_ctor_release(x_274, 0); + lean_ctor_release(x_274, 1); + x_279 = x_274; +} else { + lean_dec_ref(x_274); + x_279 = lean_box(0); +} +x_310 = lean_unbox(x_277); +lean_dec(x_277); +if (x_310 == 0) +{ +lean_object* x_311; lean_object* x_312; +lean_dec(x_279); +lean_dec(x_276); +lean_dec(x_271); +x_311 = lean_box(0); +x_312 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_2, x_11, x_5, x_4, x_6, x_311, x_8, x_278, x_275); +return x_312; +} +else +{ +lean_object* x_313; uint8_t x_314; lean_object* x_315; lean_object* x_316; uint8_t x_317; lean_object* x_318; lean_object* x_319; uint8_t x_320; +lean_dec(x_11); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_313 = lean_ctor_get(x_278, 0); +lean_inc(x_313); +x_314 = lean_ctor_get_uint8(x_278, sizeof(void*)*1); +if (lean_is_exclusive(x_278)) { + lean_ctor_release(x_278, 0); + x_315 = x_278; +} else { + lean_dec_ref(x_278); + x_315 = lean_box(0); +} +x_316 = l_Lake_instOrdJobAction; +x_317 = 1; +x_318 = lean_box(x_314); +x_319 = lean_box(x_317); +x_320 = l_instDecidableRelLe___rarg(x_316, x_318, x_319); +if (x_320 == 0) +{ +lean_object* x_321; lean_object* x_322; lean_object* x_323; +if (lean_is_scalar(x_315)) { + x_321 = lean_alloc_ctor(0, 1, 1); +} else { + x_321 = x_315; +} +lean_ctor_set(x_321, 0, x_313); +lean_ctor_set_uint8(x_321, sizeof(void*)*1, x_314); +x_322 = lean_box(0); +if (lean_is_scalar(x_279)) { + x_323 = lean_alloc_ctor(0, 2, 0); +} else { + x_323 = x_279; +} +lean_ctor_set(x_323, 0, x_322); +lean_ctor_set(x_323, 1, x_321); +x_280 = x_323; +x_281 = x_275; +goto block_309; +} +else +{ +lean_object* x_324; lean_object* x_325; lean_object* x_326; +if (lean_is_scalar(x_315)) { + x_324 = lean_alloc_ctor(0, 1, 1); +} else { + x_324 = x_315; +} +lean_ctor_set(x_324, 0, x_313); +lean_ctor_set_uint8(x_324, sizeof(void*)*1, x_317); +x_325 = lean_box(0); +if (lean_is_scalar(x_279)) { + x_326 = lean_alloc_ctor(0, 2, 0); +} else { + x_326 = x_279; +} +lean_ctor_set(x_326, 0, x_325); +lean_ctor_set(x_326, 1, x_324); +x_280 = x_326; +x_281 = x_275; +goto block_309; +} +} +block_309: +{ +lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +x_284 = lean_array_get_size(x_271); +x_285 = lean_unsigned_to_nat(0u); +x_286 = lean_nat_dec_lt(x_285, x_284); +if (x_286 == 0) +{ +uint8_t x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; +lean_dec(x_284); +lean_dec(x_271); +lean_dec(x_8); +x_287 = 1; +x_288 = lean_box(x_287); +if (lean_is_scalar(x_283)) { + x_289 = lean_alloc_ctor(0, 2, 0); +} else { + x_289 = x_283; +} +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_282); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_281); +return x_290; +} +else +{ +uint8_t x_291; +x_291 = lean_nat_dec_le(x_284, x_284); +if (x_291 == 0) +{ +uint8_t x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +lean_dec(x_284); +lean_dec(x_271); +lean_dec(x_8); +x_292 = 1; +x_293 = lean_box(x_292); +if (lean_is_scalar(x_283)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_283; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_282); +if (lean_is_scalar(x_276)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_276; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_281); +return x_295; +} +else +{ +size_t x_296; size_t x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; +lean_dec(x_283); +lean_dec(x_276); +x_296 = 0; +x_297 = lean_usize_of_nat(x_284); +lean_dec(x_284); +x_298 = lean_box(0); +x_299 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_271, x_296, x_297, x_298, x_8, x_282, x_281); +lean_dec(x_8); +lean_dec(x_271); +x_300 = lean_ctor_get(x_299, 0); +lean_inc(x_300); +x_301 = lean_ctor_get(x_299, 1); +lean_inc(x_301); +if (lean_is_exclusive(x_299)) { + lean_ctor_release(x_299, 0); + lean_ctor_release(x_299, 1); + x_302 = x_299; +} else { + lean_dec_ref(x_299); + x_302 = lean_box(0); +} +x_303 = lean_ctor_get(x_300, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_300)) { + lean_ctor_release(x_300, 0); + lean_ctor_release(x_300, 1); + x_304 = x_300; +} else { + lean_dec_ref(x_300); + x_304 = lean_box(0); +} +x_305 = 1; +x_306 = lean_box(x_305); +if (lean_is_scalar(x_304)) { + x_307 = lean_alloc_ctor(0, 2, 0); +} else { + x_307 = x_304; +} +lean_ctor_set(x_307, 0, x_306); +lean_ctor_set(x_307, 1, x_303); +if (lean_is_scalar(x_302)) { + x_308 = lean_alloc_ctor(0, 2, 0); +} else { + x_308 = x_302; +} +lean_ctor_set(x_308, 0, x_307); +lean_ctor_set(x_308, 1, x_301); +return x_308; +} +} +} +} +} +} +} +} +static lean_object* _init_l_Lake_buildFileUnlessUpToDate___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(".trace", 6); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileUnlessUpToDate(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; +x_7 = l_Lake_buildFileUnlessUpToDate___closed__1; +lean_inc(x_1); +x_8 = lean_string_append(x_1, x_7); +x_9 = lean_ctor_get(x_2, 1); +lean_inc(x_9); +x_10 = 3; +lean_inc(x_4); +lean_inc(x_1); +x_11 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2(x_1, x_3, x_1, x_2, x_8, x_10, x_9, x_4, x_5, x_6); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = lean_ctor_get(x_11, 1); +lean_inc(x_13); +lean_dec(x_11); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_Lake_fetchFileTrace(x_1, x_4, x_14, x_13); +lean_dec(x_4); +return x_15; +} +else +{ +uint8_t x_16; +lean_dec(x_4); +lean_dec(x_1); +x_16 = !lean_is_exclusive(x_11); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_11, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_12); +if (x_18 == 0) +{ +return x_11; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_12, 0); +x_20 = lean_ctor_get(x_12, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_12); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +lean_ctor_set(x_11, 0, x_21); +return x_11; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_11, 1); +lean_inc(x_22); +lean_dec(x_11); +x_23 = lean_ctor_get(x_12, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_12, 1); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +if (lean_is_scalar(x_25)) { + x_26 = lean_alloc_ctor(1, 2, 0); +} else { + x_26 = x_25; +} +lean_ctor_set(x_26, 0, x_23); +lean_ctor_set(x_26, 1, x_24); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_22); +return x_27; +} +} +} +else +{ +uint8_t x_28; +lean_dec(x_4); +lean_dec(x_1); +x_28 = !lean_is_exclusive(x_11); +if (x_28 == 0) +{ +return x_11; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_11, 0); +x_30 = lean_ctor_get(x_11, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_11); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +return x_31; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(x_1, x_2); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_5); +lean_dec(x_1); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +size_t x_8; size_t x_9; lean_object* x_10; +x_8 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_9 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_10 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_1, x_8, x_9, x_4, x_5, x_6, x_7); +lean_dec(x_5); +lean_dec(x_1); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; lean_object* x_11; +x_10 = lean_unbox(x_5); +lean_dec(x_5); +x_11 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___lambda__2(x_1, x_2, x_3, x_4, x_10, x_6, x_7, x_8, x_9); +lean_dec(x_6); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; lean_object* x_12; +x_11 = lean_unbox(x_6); +lean_dec(x_6); +x_12 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_buildFileUnlessUpToDate___spec__2(x_1, x_2, x_3, x_4, x_5, x_11, x_7, x_8, x_9, x_10); +lean_dec(x_3); +return x_12; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_buildFileAfterDep___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_buildFileAfterDep___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_buildFileAfterDep___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_ByteArray_empty; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Init.Data.String.Extra", 22); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("String.fromUTF8!", 16); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid UTF-8 string", 20); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5() { +_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_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__2; +x_2 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__3; +x_3 = lean_unsigned_to_nat(92u); +x_4 = lean_unsigned_to_nat(47u); +x_5 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__4; +x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildFileAfterDep___spec__2), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_buildFileAfterDep___spec__3(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_buildFileAfterDep___spec__4), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildFileAfterDep___spec__2), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_buildFileAfterDep___spec__3(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildFileAfterDep___spec__2), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_buildFileAfterDep___spec__3(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_buildFileAfterDep___spec__4), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildFileAfterDep___spec__2), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_buildFileAfterDep___spec__3(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = l_Lake_BuildTrace_mix(x_1, x_5); +x_10 = lean_apply_1(x_2, x_3); +lean_inc(x_4); +x_11 = l_Lake_buildFileUnlessUpToDate(x_4, x_9, x_10, x_6, x_7, x_8); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +uint8_t x_13; +x_13 = !lean_is_exclusive(x_11); +if (x_13 == 0) +{ +lean_object* x_14; uint8_t x_15; +x_14 = lean_ctor_get(x_11, 0); +lean_dec(x_14); +x_15 = !lean_is_exclusive(x_12); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_12, 0); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_4); +lean_ctor_set(x_17, 1, x_16); +lean_ctor_set(x_12, 0, x_17); +return x_11; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_12, 0); +x_19 = lean_ctor_get(x_12, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_12); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_4); +lean_ctor_set(x_20, 1, x_18); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_19); +lean_ctor_set(x_11, 0, x_21); +return x_11; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_22 = lean_ctor_get(x_11, 1); +lean_inc(x_22); +lean_dec(x_11); +x_23 = lean_ctor_get(x_12, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_12, 1); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_4); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_24); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_22); +return x_28; +} +} +else +{ +uint8_t x_29; +lean_dec(x_4); +x_29 = !lean_is_exclusive(x_11); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_11, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_12); +if (x_31 == 0) +{ +return x_11; +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_12, 0); +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_inc(x_32); +lean_dec(x_12); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +lean_ctor_set(x_11, 0, x_34); +return x_11; +} +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_35 = lean_ctor_get(x_11, 1); +lean_inc(x_35); +lean_dec(x_11); +x_36 = lean_ctor_get(x_12, 0); +lean_inc(x_36); +x_37 = lean_ctor_get(x_12, 1); +lean_inc(x_37); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_38 = x_12; +} else { + lean_dec_ref(x_12); + x_38 = lean_box(0); +} +if (lean_is_scalar(x_38)) { + x_39 = lean_alloc_ctor(1, 2, 0); +} else { + x_39 = x_38; +} +lean_ctor_set(x_39, 0, x_36); +lean_ctor_set(x_39, 1, x_37); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_35); +return x_40; +} +} +} +else +{ +uint8_t x_41; +lean_dec(x_4); +x_41 = !lean_is_exclusive(x_11); +if (x_41 == 0) +{ +return x_11; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_11, 0); +x_43 = lean_ctor_get(x_11, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_11); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +return x_44; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_4); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +static lean_object* _init_l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout/stderr:\n", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDep___rarg___lambda__1), 8, 4); +lean_closure_set(x_11, 0, x_10); +lean_closure_set(x_11, 1, x_1); +lean_closure_set(x_11, 2, x_9); +lean_closure_set(x_11, 3, x_2); +x_12 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_12, 0, x_3); +lean_closure_set(x_12, 1, x_11); +x_13 = 1; +lean_inc(x_4); +x_14 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_12, x_13, x_4, x_8, x_6); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_16, 1); +lean_inc(x_20); +lean_dec(x_16); +x_21 = l_String_isEmpty(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; uint8_t x_28; +x_22 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_23 = lean_string_append(x_22, x_19); +lean_dec(x_19); +x_24 = l_Lake_readTraceFile_x3f___closed__1; +x_25 = lean_string_append(x_23, x_24); +x_26 = 1; +x_27 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set_uint8(x_27, sizeof(void*)*1, x_26); +x_28 = !lean_is_exclusive(x_18); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_29 = lean_ctor_get(x_18, 0); +x_30 = lean_array_push(x_29, x_27); +lean_ctor_set(x_18, 0, x_30); +x_31 = lean_box(0); +x_32 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_20, x_31, x_4, x_18, x_17); +lean_dec(x_4); +return x_32; +} +else +{ +lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_33 = lean_ctor_get(x_18, 0); +x_34 = lean_ctor_get_uint8(x_18, sizeof(void*)*1); +lean_inc(x_33); +lean_dec(x_18); +x_35 = lean_array_push(x_33, x_27); +x_36 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set_uint8(x_36, sizeof(void*)*1, x_34); +x_37 = lean_box(0); +x_38 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_20, x_37, x_4, x_36, x_17); +lean_dec(x_4); +return x_38; +} +} +else +{ +lean_object* x_39; lean_object* x_40; +lean_dec(x_19); +x_39 = lean_box(0); +x_40 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_20, x_39, x_4, x_18, x_17); +lean_dec(x_4); +return x_40; +} +} +else +{ +uint8_t x_41; +lean_dec(x_4); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; uint8_t x_43; +x_42 = lean_ctor_get(x_14, 0); +lean_dec(x_42); +x_43 = !lean_is_exclusive(x_15); +if (x_43 == 0) +{ +return x_14; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_15, 0); +x_45 = lean_ctor_get(x_15, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_15); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +lean_ctor_set(x_14, 0, x_46); +return x_14; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_47 = lean_ctor_get(x_14, 1); +lean_inc(x_47); +lean_dec(x_14); +x_48 = lean_ctor_get(x_15, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_15, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_50 = x_15; +} else { + lean_dec_ref(x_15); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_4); +x_53 = !lean_is_exclusive(x_14); +if (x_53 == 0) +{ +return x_14; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_14, 0); +x_55 = lean_ctor_get(x_14, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_14); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +else +{ +uint8_t x_57; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_57 = !lean_is_exclusive(x_5); +if (x_57 == 0) +{ +lean_object* x_58; +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_5); +lean_ctor_set(x_58, 1, x_6); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_59 = lean_ctor_get(x_5, 0); +x_60 = lean_ctor_get(x_5, 1); +lean_inc(x_60); +lean_inc(x_59); +lean_dec(x_5); +x_61 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_61, 0, x_59); +lean_ctor_set(x_61, 1, x_60); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_6); +return x_62; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_2); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; +x_8 = lean_ctor_get(x_2, 0); +x_9 = lean_ctor_get(x_2, 1); +x_10 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDep___rarg___lambda__3), 6, 4); +lean_closure_set(x_10, 0, x_3); +lean_closure_set(x_10, 1, x_1); +lean_closure_set(x_10, 2, x_4); +lean_closure_set(x_10, 3, x_5); +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_io_map_task(x_10, x_8, x_11, x_12, x_6); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_13); +if (x_14 == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_13, 0); +lean_ctor_set(x_2, 0, x_15); +lean_ctor_set(x_13, 0, x_2); +return x_13; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_13, 0); +x_17 = lean_ctor_get(x_13, 1); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_13); +lean_ctor_set(x_2, 0, x_16); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_2); +lean_ctor_set(x_18, 1, x_17); +return x_18; +} +} +else +{ +uint8_t x_19; +lean_free_object(x_2); +lean_dec(x_9); +x_19 = !lean_is_exclusive(x_13); +if (x_19 == 0) +{ +return x_13; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_13, 0); +x_21 = lean_ctor_get(x_13, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_13); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_2, 0); +x_24 = lean_ctor_get(x_2, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_2); +x_25 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDep___rarg___lambda__3), 6, 4); +lean_closure_set(x_25, 0, x_3); +lean_closure_set(x_25, 1, x_1); +lean_closure_set(x_25, 2, x_4); +lean_closure_set(x_25, 3, x_5); +x_26 = l_Task_Priority_default; +x_27 = 0; +x_28 = lean_io_map_task(x_25, x_23, x_26, x_27, x_6); +if (lean_obj_tag(x_28) == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_28, 1); +lean_inc(x_30); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_31 = x_28; +} else { + lean_dec_ref(x_28); + x_31 = lean_box(0); +} +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_29); +lean_ctor_set(x_32, 1, x_24); +if (lean_is_scalar(x_31)) { + x_33 = lean_alloc_ctor(0, 2, 0); +} else { + x_33 = x_31; +} +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_30); +return x_33; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_24); +x_34 = lean_ctor_get(x_28, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_28, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_36 = x_28; +} else { + lean_dec_ref(x_28); + x_36 = lean_box(0); +} +if (lean_is_scalar(x_36)) { + x_37 = lean_alloc_ctor(1, 2, 0); +} else { + x_37 = x_36; +} +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_35); +return x_37; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDep___rarg), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDep___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepList___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDep___rarg___lambda__1), 8, 4); +lean_closure_set(x_11, 0, x_10); +lean_closure_set(x_11, 1, x_1); +lean_closure_set(x_11, 2, x_9); +lean_closure_set(x_11, 3, x_2); +x_12 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_12, 0, x_3); +lean_closure_set(x_12, 1, x_11); +x_13 = 1; +lean_inc(x_4); +x_14 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_12, x_13, x_4, x_8, x_6); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_16, 1); +lean_inc(x_20); +lean_dec(x_16); +x_21 = l_String_isEmpty(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; uint8_t x_28; +x_22 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_23 = lean_string_append(x_22, x_19); +lean_dec(x_19); +x_24 = l_Lake_readTraceFile_x3f___closed__1; +x_25 = lean_string_append(x_23, x_24); +x_26 = 1; +x_27 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set_uint8(x_27, sizeof(void*)*1, x_26); +x_28 = !lean_is_exclusive(x_18); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_29 = lean_ctor_get(x_18, 0); +x_30 = lean_array_push(x_29, x_27); +lean_ctor_set(x_18, 0, x_30); +x_31 = lean_box(0); +x_32 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_20, x_31, x_4, x_18, x_17); +lean_dec(x_4); +return x_32; +} +else +{ +lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_33 = lean_ctor_get(x_18, 0); +x_34 = lean_ctor_get_uint8(x_18, sizeof(void*)*1); +lean_inc(x_33); +lean_dec(x_18); +x_35 = lean_array_push(x_33, x_27); +x_36 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set_uint8(x_36, sizeof(void*)*1, x_34); +x_37 = lean_box(0); +x_38 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_20, x_37, x_4, x_36, x_17); +lean_dec(x_4); +return x_38; +} +} +else +{ +lean_object* x_39; lean_object* x_40; +lean_dec(x_19); +x_39 = lean_box(0); +x_40 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_20, x_39, x_4, x_18, x_17); +lean_dec(x_4); +return x_40; +} +} +else +{ +uint8_t x_41; +lean_dec(x_4); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; uint8_t x_43; +x_42 = lean_ctor_get(x_14, 0); +lean_dec(x_42); +x_43 = !lean_is_exclusive(x_15); +if (x_43 == 0) +{ +return x_14; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_15, 0); +x_45 = lean_ctor_get(x_15, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_15); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +lean_ctor_set(x_14, 0, x_46); +return x_14; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_47 = lean_ctor_get(x_14, 1); +lean_inc(x_47); +lean_dec(x_14); +x_48 = lean_ctor_get(x_15, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_15, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_50 = x_15; +} else { + lean_dec_ref(x_15); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_4); +x_53 = !lean_is_exclusive(x_14); +if (x_53 == 0) +{ +return x_14; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_14, 0); +x_55 = lean_ctor_get(x_14, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_14); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +else +{ +uint8_t x_57; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_57 = !lean_is_exclusive(x_5); +if (x_57 == 0) +{ +lean_object* x_58; +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_5); +lean_ctor_set(x_58, 1, x_6); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_59 = lean_ctor_get(x_5, 0); +x_60 = lean_ctor_get(x_5, 1); +lean_inc(x_60); +lean_inc(x_59); +lean_dec(x_5); +x_61 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_61, 0, x_59); +lean_ctor_set(x_61, 1, x_60); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_6); +return x_62; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepList___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; uint8_t x_8; +x_7 = l_Lake_BuildJob_collectList___rarg(x_2); +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_ctor_get(x_7, 1); +x_11 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDepList___rarg___lambda__1), 6, 4); +lean_closure_set(x_11, 0, x_3); +lean_closure_set(x_11, 1, x_1); +lean_closure_set(x_11, 2, x_4); +lean_closure_set(x_11, 3, x_5); +x_12 = l_Task_Priority_default; +x_13 = 0; +x_14 = lean_io_map_task(x_11, x_9, x_12, x_13, x_6); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_14, 0); +lean_ctor_set(x_7, 0, x_16); +lean_ctor_set(x_14, 0, x_7); +return x_14; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_14, 0); +x_18 = lean_ctor_get(x_14, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_14); +lean_ctor_set(x_7, 0, x_17); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_7); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +else +{ +uint8_t x_20; +lean_free_object(x_7); +lean_dec(x_10); +x_20 = !lean_is_exclusive(x_14); +if (x_20 == 0) +{ +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_14, 0); +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_14); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; +x_24 = lean_ctor_get(x_7, 0); +x_25 = lean_ctor_get(x_7, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_7); +x_26 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDepList___rarg___lambda__1), 6, 4); +lean_closure_set(x_26, 0, x_3); +lean_closure_set(x_26, 1, x_1); +lean_closure_set(x_26, 2, x_4); +lean_closure_set(x_26, 3, x_5); +x_27 = l_Task_Priority_default; +x_28 = 0; +x_29 = lean_io_map_task(x_26, x_24, x_27, x_28, x_6); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_29, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_32 = x_29; +} else { + lean_dec_ref(x_29); + x_32 = lean_box(0); +} +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_25); +if (lean_is_scalar(x_32)) { + x_34 = lean_alloc_ctor(0, 2, 0); +} else { + x_34 = x_32; +} +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_31); +return x_34; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_25); +x_35 = lean_ctor_get(x_29, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_29, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_37 = x_29; +} else { + lean_dec_ref(x_29); + x_37 = lean_box(0); +} +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_36); +return x_38; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepList(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDepList___rarg), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepArray___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; uint8_t x_8; +x_7 = l_Lake_BuildJob_collectArray___rarg(x_2); +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_ctor_get(x_7, 1); +x_11 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDepList___rarg___lambda__1), 6, 4); +lean_closure_set(x_11, 0, x_3); +lean_closure_set(x_11, 1, x_1); +lean_closure_set(x_11, 2, x_4); +lean_closure_set(x_11, 3, x_5); +x_12 = l_Task_Priority_default; +x_13 = 0; +x_14 = lean_io_map_task(x_11, x_9, x_12, x_13, x_6); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_14, 0); +lean_ctor_set(x_7, 0, x_16); +lean_ctor_set(x_14, 0, x_7); +return x_14; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_14, 0); +x_18 = lean_ctor_get(x_14, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_14); +lean_ctor_set(x_7, 0, x_17); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_7); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +else +{ +uint8_t x_20; +lean_free_object(x_7); +lean_dec(x_10); +x_20 = !lean_is_exclusive(x_14); +if (x_20 == 0) +{ +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_14, 0); +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_14); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; +x_24 = lean_ctor_get(x_7, 0); +x_25 = lean_ctor_get(x_7, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_7); +x_26 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDepList___rarg___lambda__1), 6, 4); +lean_closure_set(x_26, 0, x_3); +lean_closure_set(x_26, 1, x_1); +lean_closure_set(x_26, 2, x_4); +lean_closure_set(x_26, 3, x_5); +x_27 = l_Task_Priority_default; +x_28 = 0; +x_29 = lean_io_map_task(x_26, x_24, x_27, x_28, x_6); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_29, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_32 = x_29; +} else { + lean_dec_ref(x_29); + x_32 = lean_box(0); +} +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_25); +if (lean_is_scalar(x_32)) { + x_34 = lean_alloc_ctor(0, 2, 0); +} else { + x_34 = x_32; +} +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_31); +return x_34; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_25); +x_35 = lean_ctor_get(x_29, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_29, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_37 = x_29; +} else { + lean_dec_ref(x_29); + x_37 = lean_box(0); +} +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_36); +return x_38; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepArray(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_buildFileAfterDepArray___rarg___boxed), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildFileAfterDepArray___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildFileAfterDepArray___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputBinFile___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_computeFileHash(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_3, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_io_metadata(x_1, x_5); +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_6, 0); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_4); +lean_ctor_set(x_10, 1, x_9); +lean_ctor_set(x_6, 0, x_10); +return x_6; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_11 = lean_ctor_get(x_6, 0); +x_12 = lean_ctor_get(x_6, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_6); +x_13 = lean_ctor_get(x_11, 1); +lean_inc(x_13); +lean_dec(x_11); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_4); +lean_ctor_set(x_14, 1, x_13); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_12); +return x_15; +} +} +else +{ +uint8_t x_16; +lean_dec(x_4); +x_16 = !lean_is_exclusive(x_6); +if (x_16 == 0) +{ +return x_6; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_6, 0); +x_18 = lean_ctor_get(x_6, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_6); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +} +else +{ +uint8_t x_20; +x_20 = !lean_is_exclusive(x_3); +if (x_20 == 0) +{ +return x_3; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_3, 0); +x_22 = lean_ctor_get(x_3, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_3); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_inputBinFile___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_3, 0); +x_7 = l_Lake_BuildTrace_compute___at_Lake_inputBinFile___spec__1(x_1, x_4); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_3); +lean_ctor_set(x_7, 0, x_11); +return x_7; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_7, 0); +x_13 = lean_ctor_get(x_7, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_7); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_1); +lean_ctor_set(x_14, 1, x_12); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_3); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_13); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_dec(x_1); +x_17 = !lean_is_exclusive(x_7); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_18 = lean_ctor_get(x_7, 0); +x_19 = lean_io_error_to_string(x_18); +x_20 = 3; +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_20); +x_22 = lean_array_get_size(x_6); +x_23 = lean_array_push(x_6, x_21); +lean_ctor_set(x_3, 0, x_23); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_3); +lean_ctor_set_tag(x_7, 0); +lean_ctor_set(x_7, 0, x_24); +return x_7; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_25 = lean_ctor_get(x_7, 0); +x_26 = lean_ctor_get(x_7, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_7); +x_27 = lean_io_error_to_string(x_25); +x_28 = 3; +x_29 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set_uint8(x_29, sizeof(void*)*1, x_28); +x_30 = lean_array_get_size(x_6); +x_31 = lean_array_push(x_6, x_29); +lean_ctor_set(x_3, 0, x_31); +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_3); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_26); +return x_33; +} +} +} +else +{ +lean_object* x_34; uint8_t x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_3, 0); +x_35 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_34); +lean_dec(x_3); +x_36 = l_Lake_BuildTrace_compute___at_Lake_inputBinFile___spec__1(x_1, x_4); +if (lean_obj_tag(x_36) == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_36, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_36, 1); +lean_inc(x_38); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_39 = x_36; +} else { + lean_dec_ref(x_36); + x_39 = lean_box(0); +} +x_40 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_40, 0, x_34); +lean_ctor_set_uint8(x_40, sizeof(void*)*1, x_35); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_1); +lean_ctor_set(x_41, 1, x_37); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_40); +if (lean_is_scalar(x_39)) { + x_43 = lean_alloc_ctor(0, 2, 0); +} else { + x_43 = x_39; +} +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +return x_43; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +lean_dec(x_1); +x_44 = lean_ctor_get(x_36, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_36, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_46 = x_36; +} else { + lean_dec_ref(x_36); + x_46 = lean_box(0); +} +x_47 = lean_io_error_to_string(x_44); +x_48 = 3; +x_49 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set_uint8(x_49, sizeof(void*)*1, x_48); +x_50 = lean_array_get_size(x_34); +x_51 = lean_array_push(x_34, x_49); +x_52 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set_uint8(x_52, sizeof(void*)*1, x_35); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_50); +lean_ctor_set(x_53, 1, x_52); +if (lean_is_scalar(x_46)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_46; + lean_ctor_set_tag(x_54, 0); +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_45); +return x_54; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_inputBinFile___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = 1; +lean_inc(x_2); +x_6 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_1, x_5, x_2, x_3, x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_ctor_get(x_8, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_8, 1); +lean_inc(x_12); +lean_dec(x_8); +x_13 = l_String_isEmpty(x_11); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; uint8_t x_20; +x_14 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_15 = lean_string_append(x_14, x_11); +lean_dec(x_11); +x_16 = l_Lake_readTraceFile_x3f___closed__1; +x_17 = lean_string_append(x_15, x_16); +x_18 = 1; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = !lean_is_exclusive(x_10); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_10, 0); +x_22 = lean_array_push(x_21, x_19); +lean_ctor_set(x_10, 0, x_22); +x_23 = lean_box(0); +x_24 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_12, x_23, x_2, x_10, x_9); +lean_dec(x_2); +return x_24; +} +else +{ +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 0); +x_26 = lean_ctor_get_uint8(x_10, sizeof(void*)*1); +lean_inc(x_25); +lean_dec(x_10); +x_27 = lean_array_push(x_25, x_19); +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_26); +x_29 = lean_box(0); +x_30 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_12, x_29, x_2, x_28, x_9); +lean_dec(x_2); +return x_30; +} +} +else +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_11); +x_31 = lean_box(0); +x_32 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_12, x_31, x_2, x_10, x_9); +lean_dec(x_2); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_dec(x_2); +x_33 = !lean_is_exclusive(x_6); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = lean_ctor_get(x_6, 0); +lean_dec(x_34); +x_35 = !lean_is_exclusive(x_7); +if (x_35 == 0) +{ +return x_6; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_7, 0); +x_37 = lean_ctor_get(x_7, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_7); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +lean_ctor_set(x_6, 0, x_38); +return x_6; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_39 = lean_ctor_get(x_6, 1); +lean_inc(x_39); +lean_dec(x_6); +x_40 = lean_ctor_get(x_7, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_7, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_7)) { + lean_ctor_release(x_7, 0); + lean_ctor_release(x_7, 1); + x_42 = x_7; +} else { + lean_dec_ref(x_7); + x_42 = lean_box(0); +} +if (lean_is_scalar(x_42)) { + x_43 = lean_alloc_ctor(1, 2, 0); +} else { + x_43 = x_42; +} +lean_ctor_set(x_43, 0, x_40); +lean_ctor_set(x_43, 1, x_41); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_39); +return x_44; +} +} +} +else +{ +uint8_t x_45; +lean_dec(x_2); +x_45 = !lean_is_exclusive(x_6); +if (x_45 == 0) +{ +return x_6; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_6, 0); +x_47 = lean_ctor_get(x_6, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_6); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +return x_48; +} +} +} +} +static lean_object* _init_l_Lake_inputBinFile___closed__1() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__3; +x_2 = 0; +x_3 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_inputBinFile(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_4 = lean_alloc_closure((void*)(l_Lake_inputBinFile___lambda__1___boxed), 4, 1); +lean_closure_set(x_4, 0, x_1); +x_5 = l_Lake_inputBinFile___closed__1; +x_6 = lean_alloc_closure((void*)(l_Lake_inputBinFile___lambda__2), 4, 3); +lean_closure_set(x_6, 0, x_4); +lean_closure_set(x_6, 1, x_2); +lean_closure_set(x_6, 2, x_5); +x_7 = l_Task_Priority_default; +x_8 = lean_io_as_task(x_6, x_7, x_3); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_8, 0); +x_11 = l_Lake_readTraceFile_x3f___closed__1; +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set(x_12, 1, x_11); +lean_ctor_set(x_8, 0, x_12); +return x_8; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_13 = lean_ctor_get(x_8, 0); +x_14 = lean_ctor_get(x_8, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_8); +x_15 = l_Lake_readTraceFile_x3f___closed__1; +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_13); +lean_ctor_set(x_16, 1, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_14); +return x_17; +} +} +else +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_8); +if (x_18 == 0) +{ +return x_8; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_8, 0); +x_20 = lean_ctor_get(x_8, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_8); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +return x_21; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputBinFile___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_BuildTrace_compute___at_Lake_inputBinFile___spec__1(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_inputBinFile___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_inputBinFile___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_computeTextFileHash(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_3, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_io_metadata(x_1, x_5); +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_6, 0); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_4); +lean_ctor_set(x_10, 1, x_9); +lean_ctor_set(x_6, 0, x_10); +return x_6; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_11 = lean_ctor_get(x_6, 0); +x_12 = lean_ctor_get(x_6, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_6); +x_13 = lean_ctor_get(x_11, 1); +lean_inc(x_13); +lean_dec(x_11); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_4); +lean_ctor_set(x_14, 1, x_13); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_12); +return x_15; +} +} +else +{ +uint8_t x_16; +lean_dec(x_4); +x_16 = !lean_is_exclusive(x_6); +if (x_16 == 0) +{ +return x_6; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_6, 0); +x_18 = lean_ctor_get(x_6, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_6); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +} +else +{ +uint8_t x_20; +x_20 = !lean_is_exclusive(x_3); +if (x_20 == 0) +{ +return x_3; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_3, 0); +x_22 = lean_ctor_get(x_3, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_3); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_inputTextFile___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_3, 0); +x_7 = l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(x_1, x_4); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_3); +lean_ctor_set(x_7, 0, x_11); +return x_7; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_7, 0); +x_13 = lean_ctor_get(x_7, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_7); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_1); +lean_ctor_set(x_14, 1, x_12); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_3); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_13); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_dec(x_1); +x_17 = !lean_is_exclusive(x_7); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_18 = lean_ctor_get(x_7, 0); +x_19 = lean_io_error_to_string(x_18); +x_20 = 3; +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_20); +x_22 = lean_array_get_size(x_6); +x_23 = lean_array_push(x_6, x_21); +lean_ctor_set(x_3, 0, x_23); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_3); +lean_ctor_set_tag(x_7, 0); +lean_ctor_set(x_7, 0, x_24); +return x_7; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_25 = lean_ctor_get(x_7, 0); +x_26 = lean_ctor_get(x_7, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_7); +x_27 = lean_io_error_to_string(x_25); +x_28 = 3; +x_29 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set_uint8(x_29, sizeof(void*)*1, x_28); +x_30 = lean_array_get_size(x_6); +x_31 = lean_array_push(x_6, x_29); +lean_ctor_set(x_3, 0, x_31); +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_3); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_26); +return x_33; +} +} +} +else +{ +lean_object* x_34; uint8_t x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_3, 0); +x_35 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_34); +lean_dec(x_3); +x_36 = l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(x_1, x_4); +if (lean_obj_tag(x_36) == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_36, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_36, 1); +lean_inc(x_38); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_39 = x_36; +} else { + lean_dec_ref(x_36); + x_39 = lean_box(0); +} +x_40 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_40, 0, x_34); +lean_ctor_set_uint8(x_40, sizeof(void*)*1, x_35); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_1); +lean_ctor_set(x_41, 1, x_37); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_40); +if (lean_is_scalar(x_39)) { + x_43 = lean_alloc_ctor(0, 2, 0); +} else { + x_43 = x_39; +} +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +return x_43; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +lean_dec(x_1); +x_44 = lean_ctor_get(x_36, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_36, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_46 = x_36; +} else { + lean_dec_ref(x_36); + x_46 = lean_box(0); +} +x_47 = lean_io_error_to_string(x_44); +x_48 = 3; +x_49 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set_uint8(x_49, sizeof(void*)*1, x_48); +x_50 = lean_array_get_size(x_34); +x_51 = lean_array_push(x_34, x_49); +x_52 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set_uint8(x_52, sizeof(void*)*1, x_35); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_50); +lean_ctor_set(x_53, 1, x_52); +if (lean_is_scalar(x_46)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_46; + lean_ctor_set_tag(x_54, 0); +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_45); +return x_54; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_inputTextFile(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_4 = lean_alloc_closure((void*)(l_Lake_inputTextFile___lambda__1___boxed), 4, 1); +lean_closure_set(x_4, 0, x_1); +x_5 = l_Lake_inputBinFile___closed__1; +x_6 = lean_alloc_closure((void*)(l_Lake_inputBinFile___lambda__2), 4, 3); +lean_closure_set(x_6, 0, x_4); +lean_closure_set(x_6, 1, x_2); +lean_closure_set(x_6, 2, x_5); +x_7 = l_Task_Priority_default; +x_8 = lean_io_as_task(x_6, x_7, x_3); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_8, 0); +x_11 = l_Lake_readTraceFile_x3f___closed__1; +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set(x_12, 1, x_11); +lean_ctor_set(x_8, 0, x_12); +return x_8; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_13 = lean_ctor_get(x_8, 0); +x_14 = lean_ctor_get(x_8, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_8); +x_15 = l_Lake_readTraceFile_x3f___closed__1; +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_13); +lean_ctor_set(x_16, 1, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_14); +return x_17; +} +} +else +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_8); +if (x_18 == 0) +{ +return x_8; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_8, 0); +x_20 = lean_ctor_get(x_8, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_8); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +return x_21; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_inputTextFile___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_inputTextFile___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_inputFile(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_inputBinFile(x_1, x_2, x_3); +return x_4; +} +} +LEAN_EXPORT uint64_t l_Array_foldlMUnsafe_fold___at_Lake_buildO___spec__2(lean_object* x_1, size_t x_2, size_t x_3, uint64_t x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; uint64_t x_7; uint64_t x_8; uint64_t x_9; uint64_t x_10; size_t x_11; size_t x_12; +x_6 = lean_array_uget(x_1, x_2); +x_7 = lean_string_hash(x_6); +lean_dec(x_6); +x_8 = 1723; +x_9 = lean_uint64_mix_hash(x_8, x_7); +x_10 = lean_uint64_mix_hash(x_4, x_9); +x_11 = 1; +x_12 = lean_usize_add(x_2, x_11); +x_2 = x_12; +x_4 = x_10; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT uint64_t l_Lake_computeArrayHash___at_Lake_buildO___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; uint8_t x_4; +x_2 = lean_array_get_size(x_1); +x_3 = lean_unsigned_to_nat(0u); +x_4 = lean_nat_dec_lt(x_3, x_2); +if (x_4 == 0) +{ +uint64_t x_5; +lean_dec(x_2); +x_5 = l_Lake_Hash_nil; +return x_5; +} +else +{ +uint8_t x_6; +x_6 = lean_nat_dec_le(x_2, x_2); +if (x_6 == 0) +{ +uint64_t x_7; +lean_dec(x_2); +x_7 = l_Lake_Hash_nil; +return x_7; +} +else +{ +size_t x_8; size_t x_9; uint64_t x_10; uint64_t x_11; +x_8 = 0; +x_9 = lean_usize_of_nat(x_2); +lean_dec(x_2); +x_10 = l_Lake_Hash_nil; +x_11 = l_Array_foldlMUnsafe_fold___at_Lake_buildO___spec__2(x_1, x_8, x_9, x_10); +return x_11; +} +} +} +} +static lean_object* _init_l_Lake_buildO___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_buildO___lambda__1___closed__2() { +_start: +{ +uint32_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 0; +x_2 = l_Lake_buildO___lambda__1___closed__1; +x_3 = lean_alloc_ctor(0, 1, 4); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint32(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint64_t x_6; uint64_t x_7; uint64_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_6 = l_Lake_computeArrayHash___at_Lake_buildO___spec__1(x_1); +x_7 = l_Lake_platformTrace; +x_8 = lean_uint64_mix_hash(x_6, x_7); +x_9 = l_Lake_buildO___lambda__1___closed__2; +x_10 = lean_box_uint64(x_8); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_9); +x_12 = l_Lake_BuildTrace_mix(x_2, x_11); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_4); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_5); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_6, 0); +x_10 = l_Lake_compileO(x_1, x_2, x_3, x_4, x_9, x_7); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_10); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_10, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_11, 1); +lean_ctor_set(x_6, 0, x_15); +lean_ctor_set(x_11, 1, x_6); +return x_10; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_11, 0); +x_17 = lean_ctor_get(x_11, 1); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_11); +lean_ctor_set(x_6, 0, x_17); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set(x_18, 1, x_6); +lean_ctor_set(x_10, 0, x_18); +return x_10; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_19 = lean_ctor_get(x_10, 1); +lean_inc(x_19); +lean_dec(x_10); +x_20 = lean_ctor_get(x_11, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_11, 1); +lean_inc(x_21); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_22 = x_11; +} else { + lean_dec_ref(x_11); + x_22 = lean_box(0); +} +lean_ctor_set(x_6, 0, x_21); +if (lean_is_scalar(x_22)) { + x_23 = lean_alloc_ctor(0, 2, 0); +} else { + x_23 = x_22; +} +lean_ctor_set(x_23, 0, x_20); +lean_ctor_set(x_23, 1, x_6); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_19); +return x_24; +} +} +else +{ +uint8_t x_25; +x_25 = !lean_is_exclusive(x_10); +if (x_25 == 0) +{ +lean_object* x_26; uint8_t x_27; +x_26 = lean_ctor_get(x_10, 0); +lean_dec(x_26); +x_27 = !lean_is_exclusive(x_11); +if (x_27 == 0) +{ +lean_object* x_28; +x_28 = lean_ctor_get(x_11, 1); +lean_ctor_set(x_6, 0, x_28); +lean_ctor_set(x_11, 1, x_6); +return x_10; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_11, 0); +x_30 = lean_ctor_get(x_11, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_11); +lean_ctor_set(x_6, 0, x_30); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_6); +lean_ctor_set(x_10, 0, x_31); +return x_10; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_32 = lean_ctor_get(x_10, 1); +lean_inc(x_32); +lean_dec(x_10); +x_33 = lean_ctor_get(x_11, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_35 = x_11; +} else { + lean_dec_ref(x_11); + x_35 = lean_box(0); +} +lean_ctor_set(x_6, 0, x_34); +if (lean_is_scalar(x_35)) { + x_36 = lean_alloc_ctor(1, 2, 0); +} else { + x_36 = x_35; +} +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_6); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_32); +return x_37; +} +} +} +else +{ +lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_6, 0); +x_39 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +lean_inc(x_38); +lean_dec(x_6); +x_40 = l_Lake_compileO(x_1, x_2, x_3, x_4, x_38, x_7); +x_41 = lean_ctor_get(x_40, 0); +lean_inc(x_41); +if (lean_obj_tag(x_41) == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_42 = lean_ctor_get(x_40, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_43 = x_40; +} else { + lean_dec_ref(x_40); + x_43 = lean_box(0); +} +x_44 = lean_ctor_get(x_41, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_41, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_46 = x_41; +} else { + lean_dec_ref(x_41); + x_46 = lean_box(0); +} +x_47 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set_uint8(x_47, sizeof(void*)*1, x_39); +if (lean_is_scalar(x_46)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_46; +} +lean_ctor_set(x_48, 0, x_44); +lean_ctor_set(x_48, 1, x_47); +if (lean_is_scalar(x_43)) { + x_49 = lean_alloc_ctor(0, 2, 0); +} else { + x_49 = x_43; +} +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_42); +return x_49; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_50 = lean_ctor_get(x_40, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_51 = x_40; +} else { + lean_dec_ref(x_40); + x_51 = lean_box(0); +} +x_52 = lean_ctor_get(x_41, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_41, 1); +lean_inc(x_53); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_54 = x_41; +} else { + lean_dec_ref(x_41); + x_54 = lean_box(0); +} +x_55 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set_uint8(x_55, sizeof(void*)*1, x_39); +if (lean_is_scalar(x_54)) { + x_56 = lean_alloc_ctor(1, 2, 0); +} else { + x_56 = x_54; +} +lean_ctor_set(x_56, 0, x_52); +lean_ctor_set(x_56, 1, x_55); +if (lean_is_scalar(x_51)) { + x_57 = lean_alloc_ctor(0, 2, 0); +} else { + x_57 = x_51; +} +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_50); +return x_57; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = l_Lake_BuildTrace_mix(x_1, x_7); +x_12 = l_Array_append___rarg(x_2, x_3); +lean_inc(x_4); +x_13 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__2___boxed), 7, 4); +lean_closure_set(x_13, 0, x_4); +lean_closure_set(x_13, 1, x_5); +lean_closure_set(x_13, 2, x_12); +lean_closure_set(x_13, 3, x_6); +lean_inc(x_4); +x_14 = l_Lake_buildFileUnlessUpToDate(x_4, x_11, x_13, x_8, x_9, x_10); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_14); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_14, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_15); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_15, 0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_4); +lean_ctor_set(x_20, 1, x_19); +lean_ctor_set(x_15, 0, x_20); +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_15, 0); +x_22 = lean_ctor_get(x_15, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_15); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_4); +lean_ctor_set(x_23, 1, x_21); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_14, 0, x_24); +return x_14; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_14, 1); +lean_inc(x_25); +lean_dec(x_14); +x_26 = lean_ctor_get(x_15, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_15, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_28 = x_15; +} else { + lean_dec_ref(x_15); + x_28 = lean_box(0); +} +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_4); +lean_ctor_set(x_29, 1, x_26); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_25); +return x_31; +} +} +else +{ +uint8_t x_32; +lean_dec(x_4); +x_32 = !lean_is_exclusive(x_14); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_14, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_15); +if (x_34 == 0) +{ +return x_14; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_15, 0); +x_36 = lean_ctor_get(x_15, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_15); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_14, 0, x_37); +return x_14; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_14, 1); +lean_inc(x_38); +lean_dec(x_14); +x_39 = lean_ctor_get(x_15, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_15, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_41 = x_15; +} else { + lean_dec_ref(x_15); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_4); +x_44 = !lean_is_exclusive(x_14); +if (x_44 == 0) +{ +return x_14; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_14, 0); +x_46 = lean_ctor_get(x_14, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_14); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__3___boxed), 10, 6); +lean_closure_set(x_13, 0, x_12); +lean_closure_set(x_13, 1, x_1); +lean_closure_set(x_13, 2, x_2); +lean_closure_set(x_13, 3, x_3); +lean_closure_set(x_13, 4, x_11); +lean_closure_set(x_13, 5, x_4); +x_14 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_14, 0, x_5); +lean_closure_set(x_14, 1, x_13); +x_15 = 1; +lean_inc(x_6); +x_16 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_14, x_15, x_6, x_10, x_8); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; +x_18 = lean_ctor_get(x_17, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 1); +lean_inc(x_20); +lean_dec(x_17); +x_21 = lean_ctor_get(x_18, 0); +lean_inc(x_21); +x_22 = lean_ctor_get(x_18, 1); +lean_inc(x_22); +lean_dec(x_18); +x_23 = l_String_isEmpty(x_21); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; uint8_t x_30; +x_24 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_25 = lean_string_append(x_24, x_21); +lean_dec(x_21); +x_26 = l_Lake_readTraceFile_x3f___closed__1; +x_27 = lean_string_append(x_25, x_26); +x_28 = 1; +x_29 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set_uint8(x_29, sizeof(void*)*1, x_28); +x_30 = !lean_is_exclusive(x_20); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_31 = lean_ctor_get(x_20, 0); +x_32 = lean_array_push(x_31, x_29); +lean_ctor_set(x_20, 0, x_32); +x_33 = lean_box(0); +x_34 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_22, x_33, x_6, x_20, x_19); +lean_dec(x_6); +return x_34; +} +else +{ +lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_35 = lean_ctor_get(x_20, 0); +x_36 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_35); +lean_dec(x_20); +x_37 = lean_array_push(x_35, x_29); +x_38 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set_uint8(x_38, sizeof(void*)*1, x_36); +x_39 = lean_box(0); +x_40 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_22, x_39, x_6, x_38, x_19); +lean_dec(x_6); +return x_40; +} +} +else +{ +lean_object* x_41; lean_object* x_42; +lean_dec(x_21); +x_41 = lean_box(0); +x_42 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_22, x_41, x_6, x_20, x_19); +lean_dec(x_6); +return x_42; +} +} +else +{ +uint8_t x_43; +lean_dec(x_6); +x_43 = !lean_is_exclusive(x_16); +if (x_43 == 0) +{ +lean_object* x_44; uint8_t x_45; +x_44 = lean_ctor_get(x_16, 0); +lean_dec(x_44); +x_45 = !lean_is_exclusive(x_17); +if (x_45 == 0) +{ +return x_16; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_17, 0); +x_47 = lean_ctor_get(x_17, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_17); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +lean_ctor_set(x_16, 0, x_48); +return x_16; +} +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_49 = lean_ctor_get(x_16, 1); +lean_inc(x_49); +lean_dec(x_16); +x_50 = lean_ctor_get(x_17, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_17, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_52 = x_17; +} else { + lean_dec_ref(x_17); + x_52 = lean_box(0); +} +if (lean_is_scalar(x_52)) { + x_53 = lean_alloc_ctor(1, 2, 0); +} else { + x_53 = x_52; +} +lean_ctor_set(x_53, 0, x_50); +lean_ctor_set(x_53, 1, x_51); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_49); +return x_54; +} +} +} +else +{ +uint8_t x_55; +lean_dec(x_6); +x_55 = !lean_is_exclusive(x_16); +if (x_55 == 0) +{ +return x_16; +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_16, 0); +x_57 = lean_ctor_get(x_16, 1); +lean_inc(x_57); +lean_inc(x_56); +lean_dec(x_16); +x_58 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_58, 0, x_56); +lean_ctor_set(x_58, 1, x_57); +return x_58; +} +} +} +else +{ +uint8_t x_59; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_59 = !lean_is_exclusive(x_7); +if (x_59 == 0) +{ +lean_object* x_60; +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_7); +lean_ctor_set(x_60, 1, x_8); +return x_60; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_61 = lean_ctor_get(x_7, 0); +x_62 = lean_ctor_get(x_7, 1); +lean_inc(x_62); +lean_inc(x_61); +lean_dec(x_7); +x_63 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set(x_63, 1, x_62); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_8); +return x_64; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildO(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; uint8_t x_11; +lean_inc(x_4); +x_9 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__1___boxed), 5, 1); +lean_closure_set(x_9, 0, x_4); +x_10 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_10, 0, x_6); +lean_closure_set(x_10, 1, x_9); +x_11 = !lean_is_exclusive(x_2); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; +x_12 = lean_ctor_get(x_2, 0); +x_13 = lean_ctor_get(x_2, 1); +x_14 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__4), 8, 6); +lean_closure_set(x_14, 0, x_3); +lean_closure_set(x_14, 1, x_4); +lean_closure_set(x_14, 2, x_1); +lean_closure_set(x_14, 3, x_5); +lean_closure_set(x_14, 4, x_10); +lean_closure_set(x_14, 5, x_7); +x_15 = l_Task_Priority_default; +x_16 = 0; +x_17 = lean_io_map_task(x_14, x_12, x_15, x_16, x_8); +if (lean_obj_tag(x_17) == 0) +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_17); +if (x_18 == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_17, 0); +lean_ctor_set(x_2, 0, x_19); +lean_ctor_set(x_17, 0, x_2); +return x_17; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_17, 0); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_17); +lean_ctor_set(x_2, 0, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_2); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +} +else +{ +uint8_t x_23; +lean_free_object(x_2); +lean_dec(x_13); +x_23 = !lean_is_exclusive(x_17); +if (x_23 == 0) +{ +return x_17; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_17, 0); +x_25 = lean_ctor_get(x_17, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_17); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +return x_26; +} +} +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; +x_27 = lean_ctor_get(x_2, 0); +x_28 = lean_ctor_get(x_2, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_2); +x_29 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__4), 8, 6); +lean_closure_set(x_29, 0, x_3); +lean_closure_set(x_29, 1, x_4); +lean_closure_set(x_29, 2, x_1); +lean_closure_set(x_29, 3, x_5); +lean_closure_set(x_29, 4, x_10); +lean_closure_set(x_29, 5, x_7); +x_30 = l_Task_Priority_default; +x_31 = 0; +x_32 = lean_io_map_task(x_29, x_27, x_30, x_31, x_8); +if (lean_obj_tag(x_32) == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_33 = lean_ctor_get(x_32, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_32, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_35 = x_32; +} else { + lean_dec_ref(x_32); + x_35 = lean_box(0); +} +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_28); +if (lean_is_scalar(x_35)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_35; +} +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_34); +return x_37; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_dec(x_28); +x_38 = lean_ctor_get(x_32, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_32, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_40 = x_32; +} else { + lean_dec_ref(x_32); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +return x_41; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildO___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; uint64_t x_7; uint64_t x_8; lean_object* x_9; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = lean_unbox_uint64(x_4); +lean_dec(x_4); +x_8 = l_Array_foldlMUnsafe_fold___at_Lake_buildO___spec__2(x_1, x_5, x_6, x_7); +lean_dec(x_1); +x_9 = lean_box_uint64(x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___at_Lake_buildO___spec__1___boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = l_Lake_computeArrayHash___at_Lake_buildO___spec__1(x_1); +lean_dec(x_1); +x_3 = lean_box_uint64(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_buildO___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_1); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_buildO___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_5); +lean_dec(x_3); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_buildO___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; +x_11 = l_Lake_buildO___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_3); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_1, 2); +lean_inc(x_4); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_2); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_4 = lean_ctor_get(x_1, 1); +x_5 = lean_ctor_get(x_4, 1); +x_6 = lean_ctor_get(x_5, 1); +x_7 = lean_ctor_get(x_6, 8); +lean_inc(x_7); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_2); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_3); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; uint8_t x_10; +x_9 = l_Array_append___rarg(x_1, x_2); +x_10 = !lean_is_exclusive(x_7); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_7, 0); +x_12 = l_Lake_compileO(x_3, x_4, x_9, x_5, x_11, x_8); +lean_dec(x_9); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_12); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_12, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; +x_17 = lean_ctor_get(x_13, 1); +lean_ctor_set(x_7, 0, x_17); +lean_ctor_set(x_13, 1, x_7); +return x_12; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_13, 0); +x_19 = lean_ctor_get(x_13, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_13); +lean_ctor_set(x_7, 0, x_19); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_7); +lean_ctor_set(x_12, 0, x_20); +return x_12; +} +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_21 = lean_ctor_get(x_12, 1); +lean_inc(x_21); +lean_dec(x_12); +x_22 = lean_ctor_get(x_13, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_13, 1); +lean_inc(x_23); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_24 = x_13; +} else { + lean_dec_ref(x_13); + x_24 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_23); +if (lean_is_scalar(x_24)) { + x_25 = lean_alloc_ctor(0, 2, 0); +} else { + x_25 = x_24; +} +lean_ctor_set(x_25, 0, x_22); +lean_ctor_set(x_25, 1, x_7); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_21); +return x_26; +} +} +else +{ +uint8_t x_27; +x_27 = !lean_is_exclusive(x_12); +if (x_27 == 0) +{ +lean_object* x_28; uint8_t x_29; +x_28 = lean_ctor_get(x_12, 0); +lean_dec(x_28); +x_29 = !lean_is_exclusive(x_13); +if (x_29 == 0) +{ +lean_object* x_30; +x_30 = lean_ctor_get(x_13, 1); +lean_ctor_set(x_7, 0, x_30); +lean_ctor_set(x_13, 1, x_7); +return x_12; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_13, 0); +x_32 = lean_ctor_get(x_13, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_13); +lean_ctor_set(x_7, 0, x_32); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_7); +lean_ctor_set(x_12, 0, x_33); +return x_12; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_12, 1); +lean_inc(x_34); +lean_dec(x_12); +x_35 = lean_ctor_get(x_13, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_13, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_37 = x_13; +} else { + lean_dec_ref(x_13); + x_37 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_36); +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_7); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_34); +return x_39; +} +} +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; +x_40 = lean_ctor_get(x_7, 0); +x_41 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_7); +x_42 = l_Lake_compileO(x_3, x_4, x_9, x_5, x_40, x_8); +lean_dec(x_9); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_ctor_get(x_43, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_43, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_48 = x_43; +} else { + lean_dec_ref(x_43); + x_48 = lean_box(0); +} +x_49 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set_uint8(x_49, sizeof(void*)*1, x_41); +if (lean_is_scalar(x_48)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_48; +} +lean_ctor_set(x_50, 0, x_46); +lean_ctor_set(x_50, 1, x_49); +if (lean_is_scalar(x_45)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_45; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_44); +return x_51; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_52 = lean_ctor_get(x_42, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_53 = x_42; +} else { + lean_dec_ref(x_42); + x_53 = lean_box(0); +} +x_54 = lean_ctor_get(x_43, 0); +lean_inc(x_54); +x_55 = lean_ctor_get(x_43, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_56 = x_43; +} else { + lean_dec_ref(x_43); + x_56 = lean_box(0); +} +x_57 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set_uint8(x_57, sizeof(void*)*1, x_41); +if (lean_is_scalar(x_56)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_56; +} +lean_ctor_set(x_58, 0, x_54); +lean_ctor_set(x_58, 1, x_57); +if (lean_is_scalar(x_53)) { + x_59 = lean_alloc_ctor(0, 2, 0); +} else { + x_59 = x_53; +} +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_52); +return x_59; +} +} +} +} +static lean_object* _init_l_Lake_buildLeanO___lambda__4___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildLeanO___lambda__2___boxed), 3, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = l_Lake_BuildTrace_mix(x_1, x_6); +lean_inc(x_4); +x_11 = lean_alloc_closure((void*)(l_Lake_buildLeanO___lambda__3___boxed), 8, 4); +lean_closure_set(x_11, 0, x_2); +lean_closure_set(x_11, 1, x_3); +lean_closure_set(x_11, 2, x_4); +lean_closure_set(x_11, 3, x_5); +x_12 = l_Lake_buildLeanO___lambda__4___closed__1; +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_12); +lean_closure_set(x_13, 1, x_11); +lean_inc(x_4); +x_14 = l_Lake_buildFileUnlessUpToDate(x_4, x_10, x_13, x_7, x_8, x_9); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_14); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_14, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_15); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_15, 0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_4); +lean_ctor_set(x_20, 1, x_19); +lean_ctor_set(x_15, 0, x_20); +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_15, 0); +x_22 = lean_ctor_get(x_15, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_15); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_4); +lean_ctor_set(x_23, 1, x_21); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_14, 0, x_24); +return x_14; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_14, 1); +lean_inc(x_25); +lean_dec(x_14); +x_26 = lean_ctor_get(x_15, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_15, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_28 = x_15; +} else { + lean_dec_ref(x_15); + x_28 = lean_box(0); +} +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_4); +lean_ctor_set(x_29, 1, x_26); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_25); +return x_31; +} +} +else +{ +uint8_t x_32; +lean_dec(x_4); +x_32 = !lean_is_exclusive(x_14); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_14, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_15); +if (x_34 == 0) +{ +return x_14; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_15, 0); +x_36 = lean_ctor_get(x_15, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_15); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_14, 0, x_37); +return x_14; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_14, 1); +lean_inc(x_38); +lean_dec(x_14); +x_39 = lean_ctor_get(x_15, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_15, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_41 = x_15; +} else { + lean_dec_ref(x_15); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_4); +x_44 = !lean_is_exclusive(x_14); +if (x_44 == 0) +{ +return x_14; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_14, 0); +x_46 = lean_ctor_get(x_14, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_14); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_alloc_closure((void*)(l_Lake_buildLeanO___lambda__4), 9, 5); +lean_closure_set(x_12, 0, x_11); +lean_closure_set(x_12, 1, x_1); +lean_closure_set(x_12, 2, x_2); +lean_closure_set(x_12, 3, x_3); +lean_closure_set(x_12, 4, x_10); +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_4); +lean_closure_set(x_13, 1, x_12); +x_14 = 1; +lean_inc(x_5); +x_15 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_13, x_14, x_5, x_9, x_7); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_dec(x_17); +x_22 = l_String_isEmpty(x_20); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; uint8_t x_29; +x_23 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_24 = lean_string_append(x_23, x_20); +lean_dec(x_20); +x_25 = l_Lake_readTraceFile_x3f___closed__1; +x_26 = lean_string_append(x_24, x_25); +x_27 = 1; +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_27); +x_29 = !lean_is_exclusive(x_19); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_19, 0); +x_31 = lean_array_push(x_30, x_28); +lean_ctor_set(x_19, 0, x_31); +x_32 = lean_box(0); +x_33 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_32, x_5, x_19, x_18); +lean_dec(x_5); +return x_33; +} +else +{ +lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_19, 0); +x_35 = lean_ctor_get_uint8(x_19, sizeof(void*)*1); +lean_inc(x_34); +lean_dec(x_19); +x_36 = lean_array_push(x_34, x_28); +x_37 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set_uint8(x_37, sizeof(void*)*1, x_35); +x_38 = lean_box(0); +x_39 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_38, x_5, x_37, x_18); +lean_dec(x_5); +return x_39; +} +} +else +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_20); +x_40 = lean_box(0); +x_41 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_40, x_5, x_19, x_18); +lean_dec(x_5); +return x_41; +} +} +else +{ +uint8_t x_42; +lean_dec(x_5); +x_42 = !lean_is_exclusive(x_15); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_15, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_16); +if (x_44 == 0) +{ +return x_15; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_16, 0); +x_46 = lean_ctor_get(x_16, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_16); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_15, 0, x_47); +return x_15; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_15, 1); +lean_inc(x_48); +lean_dec(x_15); +x_49 = lean_ctor_get(x_16, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_16, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_51 = x_16; +} else { + lean_dec_ref(x_16); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +return x_53; +} +} +} +else +{ +uint8_t x_54; +lean_dec(x_5); +x_54 = !lean_is_exclusive(x_15); +if (x_54 == 0) +{ +return x_15; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_15, 0); +x_56 = lean_ctor_get(x_15, 1); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_15); +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set(x_57, 1, x_56); +return x_57; +} +} +} +else +{ +uint8_t x_58; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_58 = !lean_is_exclusive(x_6); +if (x_58 == 0) +{ +lean_object* x_59; +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_6); +lean_ctor_set(x_59, 1, x_7); +return x_59; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_60 = lean_ctor_get(x_6, 0); +x_61 = lean_ctor_get(x_6, 1); +lean_inc(x_61); +lean_inc(x_60); +lean_dec(x_6); +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_7); +return x_63; +} +} +} +} +static lean_object* _init_l_Lake_buildLeanO___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildLeanO___lambda__1___boxed), 3, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +lean_inc(x_4); +x_7 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__1___boxed), 5, 1); +lean_closure_set(x_7, 0, x_4); +x_8 = l_Lake_buildLeanO___closed__1; +x_9 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_9, 0, x_8); +lean_closure_set(x_9, 1, x_7); +x_10 = !lean_is_exclusive(x_2); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get(x_2, 1); +x_13 = lean_alloc_closure((void*)(l_Lake_buildLeanO___lambda__5), 7, 5); +lean_closure_set(x_13, 0, x_3); +lean_closure_set(x_13, 1, x_4); +lean_closure_set(x_13, 2, x_1); +lean_closure_set(x_13, 3, x_9); +lean_closure_set(x_13, 4, x_5); +x_14 = l_Task_Priority_default; +x_15 = 0; +x_16 = lean_io_map_task(x_13, x_11, x_14, x_15, x_6); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_16); +if (x_17 == 0) +{ +lean_object* x_18; +x_18 = lean_ctor_get(x_16, 0); +lean_ctor_set(x_2, 0, x_18); +lean_ctor_set(x_16, 0, x_2); +return x_16; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_16, 0); +x_20 = lean_ctor_get(x_16, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_16); +lean_ctor_set(x_2, 0, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_2); +lean_ctor_set(x_21, 1, x_20); +return x_21; +} +} +else +{ +uint8_t x_22; +lean_free_object(x_2); +lean_dec(x_12); +x_22 = !lean_is_exclusive(x_16); +if (x_22 == 0) +{ +return x_16; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_16, 0); +x_24 = lean_ctor_get(x_16, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_16); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +return x_25; +} +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; +x_26 = lean_ctor_get(x_2, 0); +x_27 = lean_ctor_get(x_2, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_2); +x_28 = lean_alloc_closure((void*)(l_Lake_buildLeanO___lambda__5), 7, 5); +lean_closure_set(x_28, 0, x_3); +lean_closure_set(x_28, 1, x_4); +lean_closure_set(x_28, 2, x_1); +lean_closure_set(x_28, 3, x_9); +lean_closure_set(x_28, 4, x_5); +x_29 = l_Task_Priority_default; +x_30 = 0; +x_31 = lean_io_map_task(x_28, x_26, x_29, x_30, x_6); +if (lean_obj_tag(x_31) == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_31, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_34 = x_31; +} else { + lean_dec_ref(x_31); + x_34 = lean_box(0); +} +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_32); +lean_ctor_set(x_35, 1, x_27); +if (lean_is_scalar(x_34)) { + x_36 = lean_alloc_ctor(0, 2, 0); +} else { + x_36 = x_34; +} +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_33); +return x_36; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +lean_dec(x_27); +x_37 = lean_ctor_get(x_31, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_31, 1); +lean_inc(x_38); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_39 = x_31; +} else { + lean_dec_ref(x_31); + x_39 = lean_box(0); +} +if (lean_is_scalar(x_39)) { + x_40 = lean_alloc_ctor(1, 2, 0); +} else { + x_40 = x_39; +} +lean_ctor_set(x_40, 0, x_37); +lean_ctor_set(x_40, 1, x_38); +return x_40; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_buildLeanO___lambda__1(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_buildLeanO___lambda__2(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanO___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_buildLeanO___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_6); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_1); +lean_ctor_set(x_5, 1, x_3); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +return x_6; +} +} +LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_4 = lean_ctor_get(x_1, 1); +x_5 = lean_ctor_get(x_4, 1); +x_6 = lean_ctor_get(x_5, 1); +x_7 = lean_ctor_get(x_6, 11); +lean_inc(x_7); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_2); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_3); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_5, 0); +x_9 = l_Lake_compileStaticLib(x_1, x_2, x_3, x_8, x_6); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_9); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_9, 0); +lean_dec(x_12); +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_14); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_10, 0); +x_16 = lean_ctor_get(x_10, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_5); +lean_ctor_set(x_9, 0, x_17); +return x_9; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_18 = lean_ctor_get(x_9, 1); +lean_inc(x_18); +lean_dec(x_9); +x_19 = lean_ctor_get(x_10, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_10, 1); +lean_inc(x_20); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_21 = x_10; +} else { + lean_dec_ref(x_10); + x_21 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_20); +if (lean_is_scalar(x_21)) { + x_22 = lean_alloc_ctor(0, 2, 0); +} else { + x_22 = x_21; +} +lean_ctor_set(x_22, 0, x_19); +lean_ctor_set(x_22, 1, x_5); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_18); +return x_23; +} +} +else +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_9); +if (x_24 == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_9, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_10); +if (x_26 == 0) +{ +lean_object* x_27; +x_27 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_27); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_10, 0); +x_29 = lean_ctor_get(x_10, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_29); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_5); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_10, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_34 = x_10; +} else { + lean_dec_ref(x_10); + x_34 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_33); +if (lean_is_scalar(x_34)) { + x_35 = lean_alloc_ctor(1, 2, 0); +} else { + x_35 = x_34; +} +lean_ctor_set(x_35, 0, x_32); +lean_ctor_set(x_35, 1, x_5); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_31); +return x_36; +} +} +} +else +{ +lean_object* x_37; uint8_t x_38; lean_object* x_39; lean_object* x_40; +x_37 = lean_ctor_get(x_5, 0); +x_38 = lean_ctor_get_uint8(x_5, sizeof(void*)*1); +lean_inc(x_37); +lean_dec(x_5); +x_39 = l_Lake_compileStaticLib(x_1, x_2, x_3, x_37, x_6); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_41 = lean_ctor_get(x_39, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_42 = x_39; +} else { + lean_dec_ref(x_39); + x_42 = lean_box(0); +} +x_43 = lean_ctor_get(x_40, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_40, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_45 = x_40; +} else { + lean_dec_ref(x_40); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_43); +lean_ctor_set(x_47, 1, x_46); +if (lean_is_scalar(x_42)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_42; +} +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_41); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_49 = lean_ctor_get(x_39, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_50 = x_39; +} else { + lean_dec_ref(x_39); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_40, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_40, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_53 = x_40; +} else { + lean_dec_ref(x_40); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_53)) { + x_55 = lean_alloc_ctor(1, 2, 0); +} else { + x_55 = x_53; +} +lean_ctor_set(x_55, 0, x_51); +lean_ctor_set(x_55, 1, x_54); +if (lean_is_scalar(x_50)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_50; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +return x_56; +} +} +} +} +static lean_object* _init_l_Lake_buildStaticLib___lambda__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildStaticLib___lambda__1___boxed), 3, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_8 = l_Lake_BuildTrace_mix(x_1, x_4); +lean_inc(x_2); +x_9 = lean_alloc_closure((void*)(l_Lake_buildStaticLib___lambda__2___boxed), 6, 2); +lean_closure_set(x_9, 0, x_2); +lean_closure_set(x_9, 1, x_3); +x_10 = l_Lake_buildStaticLib___lambda__3___closed__1; +x_11 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_11, 0, x_10); +lean_closure_set(x_11, 1, x_9); +lean_inc(x_2); +x_12 = l_Lake_buildFileUnlessUpToDate(x_2, x_8, x_11, x_5, x_6, x_7); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_12); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_12, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_13, 0); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_2); +lean_ctor_set(x_18, 1, x_17); +lean_ctor_set(x_13, 0, x_18); +return x_12; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_13, 0); +x_20 = lean_ctor_get(x_13, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_13); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_2); +lean_ctor_set(x_21, 1, x_19); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +lean_ctor_set(x_12, 0, x_22); +return x_12; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_23 = lean_ctor_get(x_12, 1); +lean_inc(x_23); +lean_dec(x_12); +x_24 = lean_ctor_get(x_13, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_13, 1); +lean_inc(x_25); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_26 = x_13; +} else { + lean_dec_ref(x_13); + x_26 = lean_box(0); +} +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_2); +lean_ctor_set(x_27, 1, x_24); +if (lean_is_scalar(x_26)) { + x_28 = lean_alloc_ctor(0, 2, 0); +} else { + x_28 = x_26; +} +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_25); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_23); +return x_29; +} +} +else +{ +uint8_t x_30; +lean_dec(x_2); +x_30 = !lean_is_exclusive(x_12); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_12, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_13); +if (x_32 == 0) +{ +return x_12; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_13, 0); +x_34 = lean_ctor_get(x_13, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_13); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_12, 0, x_35); +return x_12; +} +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_36 = lean_ctor_get(x_12, 1); +lean_inc(x_36); +lean_dec(x_12); +x_37 = lean_ctor_get(x_13, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_13, 1); +lean_inc(x_38); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_39 = x_13; +} else { + lean_dec_ref(x_13); + x_39 = lean_box(0); +} +if (lean_is_scalar(x_39)) { + x_40 = lean_alloc_ctor(1, 2, 0); +} else { + x_40 = x_39; +} +lean_ctor_set(x_40, 0, x_37); +lean_ctor_set(x_40, 1, x_38); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_36); +return x_41; +} +} +} +else +{ +uint8_t x_42; +lean_dec(x_2); +x_42 = !lean_is_exclusive(x_12); +if (x_42 == 0) +{ +return x_12; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_12, 0); +x_44 = lean_ctor_get(x_12, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_12); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +return x_45; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); +lean_dec(x_4); +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_alloc_closure((void*)(l_Lake_buildStaticLib___lambda__3), 7, 3); +lean_closure_set(x_10, 0, x_9); +lean_closure_set(x_10, 1, x_1); +lean_closure_set(x_10, 2, x_8); +x_11 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_11, 0, x_2); +lean_closure_set(x_11, 1, x_10); +x_12 = 1; +lean_inc(x_3); +x_13 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_11, x_12, x_3, x_7, x_5); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_13, 1); +lean_inc(x_16); +lean_dec(x_13); +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_ctor_get(x_15, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_15, 1); +lean_inc(x_19); +lean_dec(x_15); +x_20 = l_String_isEmpty(x_18); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; uint8_t x_27; +x_21 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_22 = lean_string_append(x_21, x_18); +lean_dec(x_18); +x_23 = l_Lake_readTraceFile_x3f___closed__1; +x_24 = lean_string_append(x_22, x_23); +x_25 = 1; +x_26 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set_uint8(x_26, sizeof(void*)*1, x_25); +x_27 = !lean_is_exclusive(x_17); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_28 = lean_ctor_get(x_17, 0); +x_29 = lean_array_push(x_28, x_26); +lean_ctor_set(x_17, 0, x_29); +x_30 = lean_box(0); +x_31 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_19, x_30, x_3, x_17, x_16); +lean_dec(x_3); +return x_31; +} +else +{ +lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_32 = lean_ctor_get(x_17, 0); +x_33 = lean_ctor_get_uint8(x_17, sizeof(void*)*1); +lean_inc(x_32); +lean_dec(x_17); +x_34 = lean_array_push(x_32, x_26); +x_35 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set_uint8(x_35, sizeof(void*)*1, x_33); +x_36 = lean_box(0); +x_37 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_19, x_36, x_3, x_35, x_16); +lean_dec(x_3); +return x_37; +} +} +else +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_18); +x_38 = lean_box(0); +x_39 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_19, x_38, x_3, x_17, x_16); +lean_dec(x_3); +return x_39; +} +} +else +{ +uint8_t x_40; +lean_dec(x_3); +x_40 = !lean_is_exclusive(x_13); +if (x_40 == 0) +{ +lean_object* x_41; uint8_t x_42; +x_41 = lean_ctor_get(x_13, 0); +lean_dec(x_41); +x_42 = !lean_is_exclusive(x_14); +if (x_42 == 0) +{ +return x_13; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_13, 0, x_45); +return x_13; +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_46 = lean_ctor_get(x_13, 1); +lean_inc(x_46); +lean_dec(x_13); +x_47 = lean_ctor_get(x_14, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_14, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_49 = x_14; +} else { + lean_dec_ref(x_14); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_46); +return x_51; +} +} +} +else +{ +uint8_t x_52; +lean_dec(x_3); +x_52 = !lean_is_exclusive(x_13); +if (x_52 == 0) +{ +return x_13; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_13, 0); +x_54 = lean_ctor_get(x_13, 1); +lean_inc(x_54); +lean_inc(x_53); +lean_dec(x_13); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +return x_55; +} +} +} +else +{ +uint8_t x_56; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_56 = !lean_is_exclusive(x_4); +if (x_56 == 0) +{ +lean_object* x_57; +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_4); +lean_ctor_set(x_57, 1, x_5); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_58 = lean_ctor_get(x_4, 0); +x_59 = lean_ctor_get(x_4, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_4); +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set(x_60, 1, x_59); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_5); +return x_61; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_5 = l_Lake_BuildTrace_nil; +x_6 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_6, 0, x_5); +x_7 = l_Lake_BuildJob_collectArray___rarg(x_2); +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_ctor_get(x_7, 1); +x_11 = lean_alloc_closure((void*)(l_Lake_buildStaticLib___lambda__4), 5, 3); +lean_closure_set(x_11, 0, x_1); +lean_closure_set(x_11, 1, x_6); +lean_closure_set(x_11, 2, x_3); +x_12 = l_Task_Priority_default; +x_13 = 0; +x_14 = lean_io_map_task(x_11, x_9, x_12, x_13, x_4); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_14, 0); +lean_ctor_set(x_7, 0, x_16); +lean_ctor_set(x_14, 0, x_7); +return x_14; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_14, 0); +x_18 = lean_ctor_get(x_14, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_14); +lean_ctor_set(x_7, 0, x_17); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_7); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +else +{ +uint8_t x_20; +lean_free_object(x_7); +lean_dec(x_10); +x_20 = !lean_is_exclusive(x_14); +if (x_20 == 0) +{ +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_14, 0); +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_14); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; +x_24 = lean_ctor_get(x_7, 0); +x_25 = lean_ctor_get(x_7, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_7); +x_26 = lean_alloc_closure((void*)(l_Lake_buildStaticLib___lambda__4), 5, 3); +lean_closure_set(x_26, 0, x_1); +lean_closure_set(x_26, 1, x_6); +lean_closure_set(x_26, 2, x_3); +x_27 = l_Task_Priority_default; +x_28 = 0; +x_29 = lean_io_map_task(x_26, x_24, x_27, x_28, x_4); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_29, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_32 = x_29; +} else { + lean_dec_ref(x_29); + x_32 = lean_box(0); +} +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_25); +if (lean_is_scalar(x_32)) { + x_34 = lean_alloc_ctor(0, 2, 0); +} else { + x_34 = x_32; +} +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_31); +return x_34; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_25); +x_35 = lean_ctor_get(x_29, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_29, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_37 = x_29; +} else { + lean_dec_ref(x_29); + x_37 = lean_box(0); +} +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_36); +return x_38; +} +} +} +} +LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_buildStaticLib___lambda__1(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildStaticLib___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildStaticLib___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_buildStaticLib(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; size_t x_10; size_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_9 = lean_array_get_size(x_1); +x_10 = lean_usize_of_nat(x_9); +lean_dec(x_9); +x_11 = 0; +x_12 = l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(x_10, x_11, x_1); +x_13 = l_Array_append___rarg(x_12, x_2); +x_14 = l_Array_append___rarg(x_13, x_3); +x_15 = !lean_is_exclusive(x_7); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_7, 0); +x_17 = l_Lake_compileSharedLib(x_4, x_14, x_5, x_16, x_8); +lean_dec(x_14); +x_18 = lean_ctor_get(x_17, 0); +lean_inc(x_18); +if (lean_obj_tag(x_18) == 0) +{ +uint8_t x_19; +x_19 = !lean_is_exclusive(x_17); +if (x_19 == 0) +{ +lean_object* x_20; uint8_t x_21; +x_20 = lean_ctor_get(x_17, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_18); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_ctor_get(x_18, 1); +lean_ctor_set(x_7, 0, x_22); +lean_ctor_set(x_18, 1, x_7); +return x_17; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_18, 0); +x_24 = lean_ctor_get(x_18, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_18); +lean_ctor_set(x_7, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_7); +lean_ctor_set(x_17, 0, x_25); +return x_17; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_26 = lean_ctor_get(x_17, 1); +lean_inc(x_26); +lean_dec(x_17); +x_27 = lean_ctor_get(x_18, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_18, 1); +lean_inc(x_28); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_29 = x_18; +} else { + lean_dec_ref(x_18); + x_29 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_28); +if (lean_is_scalar(x_29)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_29; +} +lean_ctor_set(x_30, 0, x_27); +lean_ctor_set(x_30, 1, x_7); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +return x_31; +} +} +else +{ +uint8_t x_32; +x_32 = !lean_is_exclusive(x_17); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_17, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_18); +if (x_34 == 0) +{ +lean_object* x_35; +x_35 = lean_ctor_get(x_18, 1); +lean_ctor_set(x_7, 0, x_35); +lean_ctor_set(x_18, 1, x_7); +return x_17; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_18, 0); +x_37 = lean_ctor_get(x_18, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_18); +lean_ctor_set(x_7, 0, x_37); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_7); +lean_ctor_set(x_17, 0, x_38); +return x_17; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_39 = lean_ctor_get(x_17, 1); +lean_inc(x_39); +lean_dec(x_17); +x_40 = lean_ctor_get(x_18, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_18, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_42 = x_18; +} else { + lean_dec_ref(x_18); + x_42 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_41); +if (lean_is_scalar(x_42)) { + x_43 = lean_alloc_ctor(1, 2, 0); +} else { + x_43 = x_42; +} +lean_ctor_set(x_43, 0, x_40); +lean_ctor_set(x_43, 1, x_7); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_39); +return x_44; +} +} +} +else +{ +lean_object* x_45; uint8_t x_46; lean_object* x_47; lean_object* x_48; +x_45 = lean_ctor_get(x_7, 0); +x_46 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_45); +lean_dec(x_7); +x_47 = l_Lake_compileSharedLib(x_4, x_14, x_5, x_45, x_8); +lean_dec(x_14); +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_49 = lean_ctor_get(x_47, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_50 = x_47; +} else { + lean_dec_ref(x_47); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_48, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_48, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_53 = x_48; +} else { + lean_dec_ref(x_48); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_46); +if (lean_is_scalar(x_53)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_53; +} +lean_ctor_set(x_55, 0, x_51); +lean_ctor_set(x_55, 1, x_54); +if (lean_is_scalar(x_50)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_50; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +return x_56; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_57 = lean_ctor_get(x_47, 1); +lean_inc(x_57); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_58 = x_47; +} else { + lean_dec_ref(x_47); + x_58 = lean_box(0); +} +x_59 = lean_ctor_get(x_48, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_48, 1); +lean_inc(x_60); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_61 = x_48; +} else { + lean_dec_ref(x_48); + x_61 = lean_box(0); +} +x_62 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set_uint8(x_62, sizeof(void*)*1, x_46); +if (lean_is_scalar(x_61)) { + x_63 = lean_alloc_ctor(1, 2, 0); +} else { + x_63 = x_61; +} +lean_ctor_set(x_63, 0, x_59); +lean_ctor_set(x_63, 1, x_62); +if (lean_is_scalar(x_58)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_58; +} +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_57); +return x_64; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = l_Lake_BuildTrace_mix(x_1, x_6); +lean_inc(x_5); +x_11 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLib___lambda__1___boxed), 8, 4); +lean_closure_set(x_11, 0, x_2); +lean_closure_set(x_11, 1, x_3); +lean_closure_set(x_11, 2, x_4); +lean_closure_set(x_11, 3, x_5); +x_12 = l_Lake_buildLeanO___lambda__4___closed__1; +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_12); +lean_closure_set(x_13, 1, x_11); +lean_inc(x_5); +x_14 = l_Lake_buildFileUnlessUpToDate(x_5, x_10, x_13, x_7, x_8, x_9); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_14); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_14, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_15); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_15, 0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_5); +lean_ctor_set(x_20, 1, x_19); +lean_ctor_set(x_15, 0, x_20); +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_15, 0); +x_22 = lean_ctor_get(x_15, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_15); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_5); +lean_ctor_set(x_23, 1, x_21); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_14, 0, x_24); +return x_14; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_14, 1); +lean_inc(x_25); +lean_dec(x_14); +x_26 = lean_ctor_get(x_15, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_15, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_28 = x_15; +} else { + lean_dec_ref(x_15); + x_28 = lean_box(0); +} +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_5); +lean_ctor_set(x_29, 1, x_26); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_25); +return x_31; +} +} +else +{ +uint8_t x_32; +lean_dec(x_5); +x_32 = !lean_is_exclusive(x_14); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_14, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_15); +if (x_34 == 0) +{ +return x_14; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_15, 0); +x_36 = lean_ctor_get(x_15, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_15); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_14, 0, x_37); +return x_14; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_14, 1); +lean_inc(x_38); +lean_dec(x_14); +x_39 = lean_ctor_get(x_15, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_15, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_41 = x_15; +} else { + lean_dec_ref(x_15); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_5); +x_44 = !lean_is_exclusive(x_14); +if (x_44 == 0) +{ +return x_14; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_14, 0); +x_46 = lean_ctor_get(x_14, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_14); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLib___lambda__2), 9, 5); +lean_closure_set(x_12, 0, x_11); +lean_closure_set(x_12, 1, x_10); +lean_closure_set(x_12, 2, x_1); +lean_closure_set(x_12, 3, x_2); +lean_closure_set(x_12, 4, x_3); +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_4); +lean_closure_set(x_13, 1, x_12); +x_14 = 1; +lean_inc(x_5); +x_15 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_13, x_14, x_5, x_9, x_7); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_dec(x_17); +x_22 = l_String_isEmpty(x_20); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; uint8_t x_29; +x_23 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_24 = lean_string_append(x_23, x_20); +lean_dec(x_20); +x_25 = l_Lake_readTraceFile_x3f___closed__1; +x_26 = lean_string_append(x_24, x_25); +x_27 = 1; +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_27); +x_29 = !lean_is_exclusive(x_19); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_19, 0); +x_31 = lean_array_push(x_30, x_28); +lean_ctor_set(x_19, 0, x_31); +x_32 = lean_box(0); +x_33 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_32, x_5, x_19, x_18); +lean_dec(x_5); +return x_33; +} +else +{ +lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_19, 0); +x_35 = lean_ctor_get_uint8(x_19, sizeof(void*)*1); +lean_inc(x_34); +lean_dec(x_19); +x_36 = lean_array_push(x_34, x_28); +x_37 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set_uint8(x_37, sizeof(void*)*1, x_35); +x_38 = lean_box(0); +x_39 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_38, x_5, x_37, x_18); +lean_dec(x_5); +return x_39; +} +} +else +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_20); +x_40 = lean_box(0); +x_41 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_40, x_5, x_19, x_18); +lean_dec(x_5); +return x_41; +} +} +else +{ +uint8_t x_42; +lean_dec(x_5); +x_42 = !lean_is_exclusive(x_15); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_15, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_16); +if (x_44 == 0) +{ +return x_15; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_16, 0); +x_46 = lean_ctor_get(x_16, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_16); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_15, 0, x_47); +return x_15; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_15, 1); +lean_inc(x_48); +lean_dec(x_15); +x_49 = lean_ctor_get(x_16, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_16, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_51 = x_16; +} else { + lean_dec_ref(x_16); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +return x_53; +} +} +} +else +{ +uint8_t x_54; +lean_dec(x_5); +x_54 = !lean_is_exclusive(x_15); +if (x_54 == 0) +{ +return x_15; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_15, 0); +x_56 = lean_ctor_get(x_15, 1); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_15); +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set(x_57, 1, x_56); +return x_57; +} +} +} +else +{ +uint8_t x_58; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_58 = !lean_is_exclusive(x_6); +if (x_58 == 0) +{ +lean_object* x_59; +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_6); +lean_ctor_set(x_59, 1, x_7); +return x_59; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_60 = lean_ctor_get(x_6, 0); +x_61 = lean_ctor_get(x_6, 1); +lean_inc(x_61); +lean_inc(x_60); +lean_dec(x_6); +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_7); +return x_63; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; +lean_inc(x_4); +x_7 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__1___boxed), 5, 1); +lean_closure_set(x_7, 0, x_4); +x_8 = l_Lake_buildLeanO___closed__1; +x_9 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_9, 0, x_8); +lean_closure_set(x_9, 1, x_7); +x_10 = l_Lake_BuildJob_collectArray___rarg(x_2); +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; +x_12 = lean_ctor_get(x_10, 0); +x_13 = lean_ctor_get(x_10, 1); +x_14 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLib___lambda__3), 7, 5); +lean_closure_set(x_14, 0, x_3); +lean_closure_set(x_14, 1, x_4); +lean_closure_set(x_14, 2, x_1); +lean_closure_set(x_14, 3, x_9); +lean_closure_set(x_14, 4, x_5); +x_15 = l_Task_Priority_default; +x_16 = 0; +x_17 = lean_io_map_task(x_14, x_12, x_15, x_16, x_6); +if (lean_obj_tag(x_17) == 0) +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_17); +if (x_18 == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_17, 0); +lean_ctor_set(x_10, 0, x_19); +lean_ctor_set(x_17, 0, x_10); +return x_17; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_17, 0); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_17); +lean_ctor_set(x_10, 0, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_10); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +} +else +{ +uint8_t x_23; +lean_free_object(x_10); +lean_dec(x_13); +x_23 = !lean_is_exclusive(x_17); +if (x_23 == 0) +{ +return x_17; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_17, 0); +x_25 = lean_ctor_get(x_17, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_17); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +return x_26; +} +} +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; +x_27 = lean_ctor_get(x_10, 0); +x_28 = lean_ctor_get(x_10, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_10); +x_29 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLib___lambda__3), 7, 5); +lean_closure_set(x_29, 0, x_3); +lean_closure_set(x_29, 1, x_4); +lean_closure_set(x_29, 2, x_1); +lean_closure_set(x_29, 3, x_9); +lean_closure_set(x_29, 4, x_5); +x_30 = l_Task_Priority_default; +x_31 = 0; +x_32 = lean_io_map_task(x_29, x_27, x_30, x_31, x_6); +if (lean_obj_tag(x_32) == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_33 = lean_ctor_get(x_32, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_32, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_35 = x_32; +} else { + lean_dec_ref(x_32); + x_35 = lean_box(0); +} +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_28); +if (lean_is_scalar(x_35)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_35; +} +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_34); +return x_37; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_dec(x_28); +x_38 = lean_ctor_get(x_32, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_32, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_40 = x_32; +} else { + lean_dec_ref(x_32); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +return x_41; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_buildLeanSharedLib___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLib___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildLeanSharedLib(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; uint8_t x_10; +x_9 = l_Array_append___rarg(x_1, x_2); +x_10 = !lean_is_exclusive(x_7); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_7, 0); +x_12 = l_Lake_compileExe(x_3, x_4, x_9, x_5, x_11, x_8); +lean_dec(x_9); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_12); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_12, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; +x_17 = lean_ctor_get(x_13, 1); +lean_ctor_set(x_7, 0, x_17); +lean_ctor_set(x_13, 1, x_7); +return x_12; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_13, 0); +x_19 = lean_ctor_get(x_13, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_13); +lean_ctor_set(x_7, 0, x_19); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_7); +lean_ctor_set(x_12, 0, x_20); +return x_12; +} +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_21 = lean_ctor_get(x_12, 1); +lean_inc(x_21); +lean_dec(x_12); +x_22 = lean_ctor_get(x_13, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_13, 1); +lean_inc(x_23); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_24 = x_13; +} else { + lean_dec_ref(x_13); + x_24 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_23); +if (lean_is_scalar(x_24)) { + x_25 = lean_alloc_ctor(0, 2, 0); +} else { + x_25 = x_24; +} +lean_ctor_set(x_25, 0, x_22); +lean_ctor_set(x_25, 1, x_7); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_21); +return x_26; +} +} +else +{ +uint8_t x_27; +x_27 = !lean_is_exclusive(x_12); +if (x_27 == 0) +{ +lean_object* x_28; uint8_t x_29; +x_28 = lean_ctor_get(x_12, 0); +lean_dec(x_28); +x_29 = !lean_is_exclusive(x_13); +if (x_29 == 0) +{ +lean_object* x_30; +x_30 = lean_ctor_get(x_13, 1); +lean_ctor_set(x_7, 0, x_30); +lean_ctor_set(x_13, 1, x_7); +return x_12; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_13, 0); +x_32 = lean_ctor_get(x_13, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_13); +lean_ctor_set(x_7, 0, x_32); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_7); +lean_ctor_set(x_12, 0, x_33); +return x_12; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_12, 1); +lean_inc(x_34); +lean_dec(x_12); +x_35 = lean_ctor_get(x_13, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_13, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_37 = x_13; +} else { + lean_dec_ref(x_13); + x_37 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_36); +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_7); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_34); +return x_39; +} +} +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; +x_40 = lean_ctor_get(x_7, 0); +x_41 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_7); +x_42 = l_Lake_compileExe(x_3, x_4, x_9, x_5, x_40, x_8); +lean_dec(x_9); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_ctor_get(x_43, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_43, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_48 = x_43; +} else { + lean_dec_ref(x_43); + x_48 = lean_box(0); +} +x_49 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set_uint8(x_49, sizeof(void*)*1, x_41); +if (lean_is_scalar(x_48)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_48; +} +lean_ctor_set(x_50, 0, x_46); +lean_ctor_set(x_50, 1, x_49); +if (lean_is_scalar(x_45)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_45; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_44); +return x_51; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_52 = lean_ctor_get(x_42, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_53 = x_42; +} else { + lean_dec_ref(x_42); + x_53 = lean_box(0); +} +x_54 = lean_ctor_get(x_43, 0); +lean_inc(x_54); +x_55 = lean_ctor_get(x_43, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_56 = x_43; +} else { + lean_dec_ref(x_43); + x_56 = lean_box(0); +} +x_57 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set_uint8(x_57, sizeof(void*)*1, x_41); +if (lean_is_scalar(x_56)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_56; +} +lean_ctor_set(x_58, 0, x_54); +lean_ctor_set(x_58, 1, x_57); +if (lean_is_scalar(x_53)) { + x_59 = lean_alloc_ctor(0, 2, 0); +} else { + x_59 = x_53; +} +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_52); +return x_59; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = l_Lake_BuildTrace_mix(x_1, x_6); +lean_inc(x_4); +x_11 = lean_alloc_closure((void*)(l_Lake_buildLeanExe___lambda__1___boxed), 8, 4); +lean_closure_set(x_11, 0, x_2); +lean_closure_set(x_11, 1, x_3); +lean_closure_set(x_11, 2, x_4); +lean_closure_set(x_11, 3, x_5); +x_12 = l_Lake_buildLeanO___lambda__4___closed__1; +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_12); +lean_closure_set(x_13, 1, x_11); +lean_inc(x_4); +x_14 = l_Lake_buildFileUnlessUpToDate(x_4, x_10, x_13, x_7, x_8, x_9); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_14); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_14, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_15); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_15, 0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_4); +lean_ctor_set(x_20, 1, x_19); +lean_ctor_set(x_15, 0, x_20); +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_15, 0); +x_22 = lean_ctor_get(x_15, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_15); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_4); +lean_ctor_set(x_23, 1, x_21); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_14, 0, x_24); +return x_14; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_14, 1); +lean_inc(x_25); +lean_dec(x_14); +x_26 = lean_ctor_get(x_15, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_15, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_28 = x_15; +} else { + lean_dec_ref(x_15); + x_28 = lean_box(0); +} +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_4); +lean_ctor_set(x_29, 1, x_26); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_25); +return x_31; +} +} +else +{ +uint8_t x_32; +lean_dec(x_4); +x_32 = !lean_is_exclusive(x_14); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_14, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_15); +if (x_34 == 0) +{ +return x_14; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_15, 0); +x_36 = lean_ctor_get(x_15, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_15); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_14, 0, x_37); +return x_14; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_14, 1); +lean_inc(x_38); +lean_dec(x_14); +x_39 = lean_ctor_get(x_15, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_15, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_41 = x_15; +} else { + lean_dec_ref(x_15); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_4); +x_44 = !lean_is_exclusive(x_14); +if (x_44 == 0) +{ +return x_14; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_14, 0); +x_46 = lean_ctor_get(x_14, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_14); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_alloc_closure((void*)(l_Lake_buildLeanExe___lambda__2), 9, 5); +lean_closure_set(x_12, 0, x_11); +lean_closure_set(x_12, 1, x_1); +lean_closure_set(x_12, 2, x_2); +lean_closure_set(x_12, 3, x_3); +lean_closure_set(x_12, 4, x_10); +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_4); +lean_closure_set(x_13, 1, x_12); +x_14 = 1; +lean_inc(x_5); +x_15 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_13, x_14, x_5, x_9, x_7); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_dec(x_17); +x_22 = l_String_isEmpty(x_20); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; uint8_t x_29; +x_23 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_24 = lean_string_append(x_23, x_20); +lean_dec(x_20); +x_25 = l_Lake_readTraceFile_x3f___closed__1; +x_26 = lean_string_append(x_24, x_25); +x_27 = 1; +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_27); +x_29 = !lean_is_exclusive(x_19); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_19, 0); +x_31 = lean_array_push(x_30, x_28); +lean_ctor_set(x_19, 0, x_31); +x_32 = lean_box(0); +x_33 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_32, x_5, x_19, x_18); +lean_dec(x_5); +return x_33; +} +else +{ +lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_19, 0); +x_35 = lean_ctor_get_uint8(x_19, sizeof(void*)*1); +lean_inc(x_34); +lean_dec(x_19); +x_36 = lean_array_push(x_34, x_28); +x_37 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set_uint8(x_37, sizeof(void*)*1, x_35); +x_38 = lean_box(0); +x_39 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_38, x_5, x_37, x_18); +lean_dec(x_5); +return x_39; +} +} +else +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_20); +x_40 = lean_box(0); +x_41 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_21, x_40, x_5, x_19, x_18); +lean_dec(x_5); +return x_41; +} +} +else +{ +uint8_t x_42; +lean_dec(x_5); +x_42 = !lean_is_exclusive(x_15); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_15, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_16); +if (x_44 == 0) +{ +return x_15; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_16, 0); +x_46 = lean_ctor_get(x_16, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_16); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_15, 0, x_47); +return x_15; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_15, 1); +lean_inc(x_48); +lean_dec(x_15); +x_49 = lean_ctor_get(x_16, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_16, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_51 = x_16; +} else { + lean_dec_ref(x_16); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +return x_53; +} +} +} +else +{ +uint8_t x_54; +lean_dec(x_5); +x_54 = !lean_is_exclusive(x_15); +if (x_54 == 0) +{ +return x_15; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_15, 0); +x_56 = lean_ctor_get(x_15, 1); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_15); +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set(x_57, 1, x_56); +return x_57; +} +} +} +else +{ +uint8_t x_58; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_58 = !lean_is_exclusive(x_6); +if (x_58 == 0) +{ +lean_object* x_59; +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_6); +lean_ctor_set(x_59, 1, x_7); +return x_59; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_60 = lean_ctor_get(x_6, 0); +x_61 = lean_ctor_get(x_6, 1); +lean_inc(x_61); +lean_inc(x_60); +lean_dec(x_6); +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_7); +return x_63; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanExe(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; +lean_inc(x_4); +x_7 = lean_alloc_closure((void*)(l_Lake_buildO___lambda__1___boxed), 5, 1); +lean_closure_set(x_7, 0, x_4); +x_8 = l_Lake_buildLeanO___closed__1; +x_9 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_9, 0, x_8); +lean_closure_set(x_9, 1, x_7); +x_10 = l_Lake_BuildJob_collectArray___rarg(x_2); +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; +x_12 = lean_ctor_get(x_10, 0); +x_13 = lean_ctor_get(x_10, 1); +x_14 = lean_alloc_closure((void*)(l_Lake_buildLeanExe___lambda__3), 7, 5); +lean_closure_set(x_14, 0, x_3); +lean_closure_set(x_14, 1, x_4); +lean_closure_set(x_14, 2, x_1); +lean_closure_set(x_14, 3, x_9); +lean_closure_set(x_14, 4, x_5); +x_15 = l_Task_Priority_default; +x_16 = 0; +x_17 = lean_io_map_task(x_14, x_12, x_15, x_16, x_6); +if (lean_obj_tag(x_17) == 0) +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_17); +if (x_18 == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_17, 0); +lean_ctor_set(x_10, 0, x_19); +lean_ctor_set(x_17, 0, x_10); +return x_17; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_17, 0); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_17); +lean_ctor_set(x_10, 0, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_10); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +} +else +{ +uint8_t x_23; +lean_free_object(x_10); +lean_dec(x_13); +x_23 = !lean_is_exclusive(x_17); +if (x_23 == 0) +{ +return x_17; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_17, 0); +x_25 = lean_ctor_get(x_17, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_17); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +return x_26; +} +} +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; +x_27 = lean_ctor_get(x_10, 0); +x_28 = lean_ctor_get(x_10, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_10); +x_29 = lean_alloc_closure((void*)(l_Lake_buildLeanExe___lambda__3), 7, 5); +lean_closure_set(x_29, 0, x_3); +lean_closure_set(x_29, 1, x_4); +lean_closure_set(x_29, 2, x_1); +lean_closure_set(x_29, 3, x_9); +lean_closure_set(x_29, 4, x_5); +x_30 = l_Task_Priority_default; +x_31 = 0; +x_32 = lean_io_map_task(x_29, x_27, x_30, x_31, x_6); +if (lean_obj_tag(x_32) == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_33 = lean_ctor_get(x_32, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_32, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_35 = x_32; +} else { + lean_dec_ref(x_32); + x_35 = lean_box(0); +} +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_28); +if (lean_is_scalar(x_35)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_35; +} +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_34); +return x_37; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_dec(x_28); +x_38 = lean_ctor_get(x_32, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_32, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_40 = x_32; +} else { + lean_dec_ref(x_32); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +return x_41; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_buildLeanExe___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_6); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanExe___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildLeanExe(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_5, 0); +x_9 = l_Lake_compileSharedLib(x_1, x_2, x_3, x_8, x_6); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_9); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_9, 0); +lean_dec(x_12); +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_14); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_10, 0); +x_16 = lean_ctor_get(x_10, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_5); +lean_ctor_set(x_9, 0, x_17); +return x_9; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_18 = lean_ctor_get(x_9, 1); +lean_inc(x_18); +lean_dec(x_9); +x_19 = lean_ctor_get(x_10, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_10, 1); +lean_inc(x_20); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_21 = x_10; +} else { + lean_dec_ref(x_10); + x_21 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_20); +if (lean_is_scalar(x_21)) { + x_22 = lean_alloc_ctor(0, 2, 0); +} else { + x_22 = x_21; +} +lean_ctor_set(x_22, 0, x_19); +lean_ctor_set(x_22, 1, x_5); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_18); +return x_23; +} +} +else +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_9); +if (x_24 == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_9, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_10); +if (x_26 == 0) +{ +lean_object* x_27; +x_27 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_27); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_10, 0); +x_29 = lean_ctor_get(x_10, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_29); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_5); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_10, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_34 = x_10; +} else { + lean_dec_ref(x_10); + x_34 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_33); +if (lean_is_scalar(x_34)) { + x_35 = lean_alloc_ctor(1, 2, 0); +} else { + x_35 = x_34; +} +lean_ctor_set(x_35, 0, x_32); +lean_ctor_set(x_35, 1, x_5); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_31); +return x_36; +} +} +} +else +{ +lean_object* x_37; uint8_t x_38; lean_object* x_39; lean_object* x_40; +x_37 = lean_ctor_get(x_5, 0); +x_38 = lean_ctor_get_uint8(x_5, sizeof(void*)*1); +lean_inc(x_37); +lean_dec(x_5); +x_39 = l_Lake_compileSharedLib(x_1, x_2, x_3, x_37, x_6); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_41 = lean_ctor_get(x_39, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_42 = x_39; +} else { + lean_dec_ref(x_39); + x_42 = lean_box(0); +} +x_43 = lean_ctor_get(x_40, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_40, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_45 = x_40; +} else { + lean_dec_ref(x_40); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_43); +lean_ctor_set(x_47, 1, x_46); +if (lean_is_scalar(x_42)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_42; +} +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_41); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_49 = lean_ctor_get(x_39, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_50 = x_39; +} else { + lean_dec_ref(x_39); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_40, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_40, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_53 = x_40; +} else { + lean_dec_ref(x_40); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_53)) { + x_55 = lean_alloc_ctor(1, 2, 0); +} else { + x_55 = x_53; +} +lean_ctor_set(x_55, 0, x_51); +lean_ctor_set(x_55, 1, x_54); +if (lean_is_scalar(x_50)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_50; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +return x_56; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint64_t x_10; uint64_t x_11; uint64_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_10 = l_Lake_computeArrayHash___at_Lake_buildO___spec__1(x_1); +x_11 = l_Lake_platformTrace; +x_12 = lean_uint64_mix_hash(x_10, x_11); +x_13 = l_Lake_buildO___lambda__1___closed__2; +x_14 = lean_box_uint64(x_12); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +x_16 = l_Lake_BuildTrace_mix(x_6, x_15); +x_17 = l_Lake_BuildTrace_mix(x_2, x_16); +x_18 = l_Array_append___rarg(x_3, x_4); +x_19 = l_Array_append___rarg(x_18, x_1); +lean_inc(x_5); +x_20 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLibOfStatic___lambda__1___boxed), 6, 2); +lean_closure_set(x_20, 0, x_5); +lean_closure_set(x_20, 1, x_19); +x_21 = l_Lake_buildLeanO___lambda__4___closed__1; +x_22 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_22, 0, x_21); +lean_closure_set(x_22, 1, x_20); +lean_inc(x_5); +x_23 = l_Lake_buildFileUnlessUpToDate(x_5, x_17, x_22, x_7, x_8, x_9); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; +x_24 = lean_ctor_get(x_23, 0); +lean_inc(x_24); +if (lean_obj_tag(x_24) == 0) +{ +uint8_t x_25; +x_25 = !lean_is_exclusive(x_23); +if (x_25 == 0) +{ +lean_object* x_26; uint8_t x_27; +x_26 = lean_ctor_get(x_23, 0); +lean_dec(x_26); +x_27 = !lean_is_exclusive(x_24); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_24, 0); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_5); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_24, 0, x_29); +return x_23; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_24, 0); +x_31 = lean_ctor_get(x_24, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_24); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_5); +lean_ctor_set(x_32, 1, x_30); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_31); +lean_ctor_set(x_23, 0, x_33); +return x_23; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_34 = lean_ctor_get(x_23, 1); +lean_inc(x_34); +lean_dec(x_23); +x_35 = lean_ctor_get(x_24, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_24, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_37 = x_24; +} else { + lean_dec_ref(x_24); + x_37 = lean_box(0); +} +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_5); +lean_ctor_set(x_38, 1, x_35); +if (lean_is_scalar(x_37)) { + x_39 = lean_alloc_ctor(0, 2, 0); +} else { + x_39 = x_37; +} +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_36); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_34); +return x_40; +} +} +else +{ +uint8_t x_41; +lean_dec(x_5); +x_41 = !lean_is_exclusive(x_23); +if (x_41 == 0) +{ +lean_object* x_42; uint8_t x_43; +x_42 = lean_ctor_get(x_23, 0); +lean_dec(x_42); +x_43 = !lean_is_exclusive(x_24); +if (x_43 == 0) +{ +return x_23; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_24, 0); +x_45 = lean_ctor_get(x_24, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_24); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +lean_ctor_set(x_23, 0, x_46); +return x_23; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_47 = lean_ctor_get(x_23, 1); +lean_inc(x_47); +lean_dec(x_23); +x_48 = lean_ctor_get(x_24, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_24, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_50 = x_24; +} else { + lean_dec_ref(x_24); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_5); +x_53 = !lean_is_exclusive(x_23); +if (x_53 == 0) +{ +return x_23; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_23, 0); +x_55 = lean_ctor_get(x_23, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_23); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +} +static lean_object* _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(3u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-Wl,--whole-archive", 19); +return x_1; +} +} +static lean_object* _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__1; +x_2 = l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__2; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-Wl,--no-whole-archive", 22); +return x_1; +} +} +static lean_object* _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-Wl,-force_load,", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_61; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); +lean_dec(x_4); +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = l_Lake_sharedLibExt; +lean_inc(x_8); +x_11 = l_System_FilePath_withExtension(x_8, x_10); +x_61 = l_System_Platform_isOSX; +if (x_61 == 0) +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_62 = l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__3; +x_63 = lean_array_push(x_62, x_8); +x_64 = l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__4; +x_65 = lean_array_push(x_63, x_64); +x_12 = x_65; +goto block_60; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_66 = l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__5; +x_67 = lean_string_append(x_66, x_8); +lean_dec(x_8); +x_68 = l_Lake_readTraceFile_x3f___closed__1; +x_69 = lean_string_append(x_67, x_68); +x_70 = l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__6; +x_71 = lean_array_push(x_70, x_69); +x_12 = x_71; +goto block_60; +} +block_60: +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; +x_13 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLibOfStatic___lambda__2___boxed), 9, 5); +lean_closure_set(x_13, 0, x_1); +lean_closure_set(x_13, 1, x_9); +lean_closure_set(x_13, 2, x_12); +lean_closure_set(x_13, 3, x_2); +lean_closure_set(x_13, 4, x_11); +x_14 = l_Lake_buildLeanO___closed__1; +x_15 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_15, 0, x_14); +lean_closure_set(x_15, 1, x_13); +x_16 = 1; +lean_inc(x_3); +x_17 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_15, x_16, x_3, x_7, x_5); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; +x_18 = lean_ctor_get(x_17, 0); +lean_inc(x_18); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_17, 1); +lean_inc(x_20); +lean_dec(x_17); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = lean_ctor_get(x_19, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_19, 1); +lean_inc(x_23); +lean_dec(x_19); +x_24 = l_String_isEmpty(x_22); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; lean_object* x_30; uint8_t x_31; +x_25 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_26 = lean_string_append(x_25, x_22); +lean_dec(x_22); +x_27 = l_Lake_readTraceFile_x3f___closed__1; +x_28 = lean_string_append(x_26, x_27); +x_29 = 1; +x_30 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set_uint8(x_30, sizeof(void*)*1, x_29); +x_31 = !lean_is_exclusive(x_21); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_32 = lean_ctor_get(x_21, 0); +x_33 = lean_array_push(x_32, x_30); +lean_ctor_set(x_21, 0, x_33); +x_34 = lean_box(0); +x_35 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_23, x_34, x_3, x_21, x_20); +lean_dec(x_3); +return x_35; +} +else +{ +lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_36 = lean_ctor_get(x_21, 0); +x_37 = lean_ctor_get_uint8(x_21, sizeof(void*)*1); +lean_inc(x_36); +lean_dec(x_21); +x_38 = lean_array_push(x_36, x_30); +x_39 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set_uint8(x_39, sizeof(void*)*1, x_37); +x_40 = lean_box(0); +x_41 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_23, x_40, x_3, x_39, x_20); +lean_dec(x_3); +return x_41; +} +} +else +{ +lean_object* x_42; lean_object* x_43; +lean_dec(x_22); +x_42 = lean_box(0); +x_43 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_23, x_42, x_3, x_21, x_20); +lean_dec(x_3); +return x_43; +} +} +else +{ +uint8_t x_44; +lean_dec(x_3); +x_44 = !lean_is_exclusive(x_17); +if (x_44 == 0) +{ +lean_object* x_45; uint8_t x_46; +x_45 = lean_ctor_get(x_17, 0); +lean_dec(x_45); +x_46 = !lean_is_exclusive(x_18); +if (x_46 == 0) +{ +return x_17; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_18, 0); +x_48 = lean_ctor_get(x_18, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_18); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +lean_ctor_set(x_17, 0, x_49); +return x_17; +} +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_50 = lean_ctor_get(x_17, 1); +lean_inc(x_50); +lean_dec(x_17); +x_51 = lean_ctor_get(x_18, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_18, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_53 = x_18; +} else { + lean_dec_ref(x_18); + x_53 = lean_box(0); +} +if (lean_is_scalar(x_53)) { + x_54 = lean_alloc_ctor(1, 2, 0); +} else { + x_54 = x_53; +} +lean_ctor_set(x_54, 0, x_51); +lean_ctor_set(x_54, 1, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_50); +return x_55; +} +} +} +else +{ +uint8_t x_56; +lean_dec(x_3); +x_56 = !lean_is_exclusive(x_17); +if (x_56 == 0) +{ +return x_17; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_57 = lean_ctor_get(x_17, 0); +x_58 = lean_ctor_get(x_17, 1); +lean_inc(x_58); +lean_inc(x_57); +lean_dec(x_17); +x_59 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_59, 0, x_57); +lean_ctor_set(x_59, 1, x_58); +return x_59; +} +} +} +} +else +{ +uint8_t x_72; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_72 = !lean_is_exclusive(x_4); +if (x_72 == 0) +{ +lean_object* x_73; +x_73 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_73, 0, x_4); +lean_ctor_set(x_73, 1, x_5); +return x_73; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_74 = lean_ctor_get(x_4, 0); +x_75 = lean_ctor_get(x_4, 1); +lean_inc(x_75); +lean_inc(x_74); +lean_dec(x_4); +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_5); +return x_77; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_1); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; +x_7 = lean_ctor_get(x_1, 0); +x_8 = lean_ctor_get(x_1, 1); +x_9 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLibOfStatic___lambda__3), 5, 3); +lean_closure_set(x_9, 0, x_3); +lean_closure_set(x_9, 1, x_2); +lean_closure_set(x_9, 2, x_4); +x_10 = l_Task_Priority_default; +x_11 = 0; +x_12 = lean_io_map_task(x_9, x_7, x_10, x_11, x_5); +if (lean_obj_tag(x_12) == 0) +{ +uint8_t x_13; +x_13 = !lean_is_exclusive(x_12); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_ctor_set(x_1, 0, x_14); +lean_ctor_set(x_12, 0, x_1); +return x_12; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_12, 0); +x_16 = lean_ctor_get(x_12, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_12); +lean_ctor_set(x_1, 0, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_1); +lean_ctor_set(x_17, 1, x_16); +return x_17; +} +} +else +{ +uint8_t x_18; +lean_free_object(x_1); +lean_dec(x_8); +x_18 = !lean_is_exclusive(x_12); +if (x_18 == 0) +{ +return x_12; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_12, 0); +x_20 = lean_ctor_get(x_12, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_12); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +return x_21; +} +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_1, 0); +x_23 = lean_ctor_get(x_1, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_1); +x_24 = lean_alloc_closure((void*)(l_Lake_buildLeanSharedLibOfStatic___lambda__3), 5, 3); +lean_closure_set(x_24, 0, x_3); +lean_closure_set(x_24, 1, x_2); +lean_closure_set(x_24, 2, x_4); +x_25 = l_Task_Priority_default; +x_26 = 0; +x_27 = lean_io_map_task(x_24, x_22, x_25, x_26, x_5); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_27, 1); +lean_inc(x_29); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_30 = x_27; +} else { + lean_dec_ref(x_27); + x_30 = lean_box(0); +} +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_28); +lean_ctor_set(x_31, 1, x_23); +if (lean_is_scalar(x_30)) { + x_32 = lean_alloc_ctor(0, 2, 0); +} else { + x_32 = x_30; +} +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_29); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_23); +x_33 = lean_ctor_get(x_27, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_27, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_35 = x_27; +} else { + lean_dec_ref(x_27); + x_35 = lean_box(0); +} +if (lean_is_scalar(x_35)) { + x_36 = lean_alloc_ctor(1, 2, 0); +} else { + x_36 = x_35; +} +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_34); +return x_36; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildLeanSharedLibOfStatic___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildLeanSharedLibOfStatic___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_buildLeanSharedLibOfStatic___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_4); +lean_dec(x_1); +return x_10; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_computeDynlibOfShared___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_computeDynlibOfShared___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_computeDynlibOfShared___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_computeDynlibOfShared___spec__2), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_computeDynlibOfShared___spec__3(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_computeDynlibOfShared___spec__4), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_computeDynlibOfShared___spec__2), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_computeDynlibOfShared___spec__3(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_computeDynlibOfShared___spec__2), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_computeDynlibOfShared___spec__3(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_computeDynlibOfShared___spec__4), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_computeDynlibOfShared___spec__2), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_computeDynlibOfShared___spec__3(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; uint8_t x_7; +x_5 = 3; +x_6 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set_uint8(x_6, sizeof(void*)*1, x_5); +x_7 = !lean_is_exclusive(x_3); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_8 = lean_ctor_get(x_3, 0); +x_9 = lean_array_get_size(x_8); +x_10 = lean_array_push(x_8, x_6); +lean_ctor_set(x_3, 0, x_10); +x_11 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_11, 0, x_9); +lean_ctor_set(x_11, 1, x_3); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_4); +return x_12; +} +else +{ +lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_13 = lean_ctor_get(x_3, 0); +x_14 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_13); +lean_dec(x_3); +x_15 = lean_array_get_size(x_13); +x_16 = lean_array_push(x_13, x_6); +x_17 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set_uint8(x_17, sizeof(void*)*1, x_14); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_15); +lean_ctor_set(x_18, 1, x_17); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_4); +return x_19; +} +} +} +static lean_object* _init_l_Lake_computeDynlibOfShared___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("shared library `", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_computeDynlibOfShared___lambda__2___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("` has no file name", 18); +return x_1; +} +} +static lean_object* _init_l_Lake_computeDynlibOfShared___lambda__2___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("lib", 3); +return x_1; +} +} +static lean_object* _init_l_Lake_computeDynlibOfShared___lambda__2___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("` does not start with `lib`; this is not supported on Unix", 58); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_52; +x_4 = lean_ctor_get(x_2, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +lean_dec(x_2); +x_52 = !lean_is_exclusive(x_4); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_4, 0); +x_54 = lean_ctor_get(x_4, 1); +lean_inc(x_53); +x_55 = l_System_FilePath_fileStem(x_53); +if (lean_obj_tag(x_55) == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_free_object(x_4); +lean_dec(x_54); +x_56 = l_Lake_computeDynlibOfShared___lambda__2___closed__1; +x_57 = lean_string_append(x_56, x_53); +lean_dec(x_53); +x_58 = l_Lake_computeDynlibOfShared___lambda__2___closed__2; +x_59 = lean_string_append(x_57, x_58); +x_60 = lean_alloc_closure((void*)(l_Lake_computeDynlibOfShared___lambda__1___boxed), 4, 1); +lean_closure_set(x_60, 0, x_59); +x_6 = x_60; +goto block_51; +} +else +{ +lean_object* x_61; uint8_t x_62; +x_61 = lean_ctor_get(x_55, 0); +lean_inc(x_61); +lean_dec(x_55); +x_62 = l_System_Platform_isWindows; +if (x_62 == 0) +{ +lean_object* x_63; uint8_t x_64; +x_63 = l_Lake_computeDynlibOfShared___lambda__2___closed__3; +lean_inc(x_61); +x_64 = l_String_startsWith(x_61, x_63); +if (x_64 == 0) +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_61); +lean_free_object(x_4); +lean_dec(x_54); +x_65 = l_Lake_computeDynlibOfShared___lambda__2___closed__1; +x_66 = lean_string_append(x_65, x_53); +lean_dec(x_53); +x_67 = l_Lake_computeDynlibOfShared___lambda__2___closed__4; +x_68 = lean_string_append(x_66, x_67); +x_69 = lean_alloc_closure((void*)(l_Lake_computeDynlibOfShared___lambda__1___boxed), 4, 1); +lean_closure_set(x_69, 0, x_68); +x_6 = x_69; +goto block_51; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_70 = lean_unsigned_to_nat(3u); +x_71 = l_String_drop(x_61, x_70); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_53); +lean_ctor_set(x_72, 1, x_71); +lean_ctor_set(x_4, 0, x_72); +x_73 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_73, 0, x_4); +x_6 = x_73; +goto block_51; +} +} +else +{ +lean_object* x_74; lean_object* x_75; +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_53); +lean_ctor_set(x_74, 1, x_61); +lean_ctor_set(x_4, 0, x_74); +x_75 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_75, 0, x_4); +x_6 = x_75; +goto block_51; +} +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_4, 0); +x_77 = lean_ctor_get(x_4, 1); +lean_inc(x_77); +lean_inc(x_76); +lean_dec(x_4); +lean_inc(x_76); +x_78 = l_System_FilePath_fileStem(x_76); +if (lean_obj_tag(x_78) == 0) +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_dec(x_77); +x_79 = l_Lake_computeDynlibOfShared___lambda__2___closed__1; +x_80 = lean_string_append(x_79, x_76); +lean_dec(x_76); +x_81 = l_Lake_computeDynlibOfShared___lambda__2___closed__2; +x_82 = lean_string_append(x_80, x_81); +x_83 = lean_alloc_closure((void*)(l_Lake_computeDynlibOfShared___lambda__1___boxed), 4, 1); +lean_closure_set(x_83, 0, x_82); +x_6 = x_83; +goto block_51; +} +else +{ +lean_object* x_84; uint8_t x_85; +x_84 = lean_ctor_get(x_78, 0); +lean_inc(x_84); +lean_dec(x_78); +x_85 = l_System_Platform_isWindows; +if (x_85 == 0) +{ +lean_object* x_86; uint8_t x_87; +x_86 = l_Lake_computeDynlibOfShared___lambda__2___closed__3; +lean_inc(x_84); +x_87 = l_String_startsWith(x_84, x_86); +if (x_87 == 0) +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; +lean_dec(x_84); +lean_dec(x_77); +x_88 = l_Lake_computeDynlibOfShared___lambda__2___closed__1; +x_89 = lean_string_append(x_88, x_76); +lean_dec(x_76); +x_90 = l_Lake_computeDynlibOfShared___lambda__2___closed__4; +x_91 = lean_string_append(x_89, x_90); +x_92 = lean_alloc_closure((void*)(l_Lake_computeDynlibOfShared___lambda__1___boxed), 4, 1); +lean_closure_set(x_92, 0, x_91); +x_6 = x_92; +goto block_51; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_93 = lean_unsigned_to_nat(3u); +x_94 = l_String_drop(x_84, x_93); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_76); +lean_ctor_set(x_95, 1, x_94); +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_77); +x_97 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_97, 0, x_96); +x_6 = x_97; +goto block_51; +} +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_76); +lean_ctor_set(x_98, 1, x_84); +x_99 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_99, 0, x_98); +lean_ctor_set(x_99, 1, x_77); +x_100 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_100, 0, x_99); +x_6 = x_100; +goto block_51; +} +} +} +block_51: +{ +uint8_t x_7; lean_object* x_8; +x_7 = 1; +lean_inc(x_1); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1(x_6, x_7, x_1, x_5, x_3); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_dec(x_10); +x_15 = l_String_isEmpty(x_13); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; uint8_t x_22; +x_16 = l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1; +x_17 = lean_string_append(x_16, x_13); +lean_dec(x_13); +x_18 = l_Lake_readTraceFile_x3f___closed__1; +x_19 = lean_string_append(x_17, x_18); +x_20 = 1; +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_20); +x_22 = !lean_is_exclusive(x_12); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_12, 0); +x_24 = lean_array_push(x_23, x_21); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_box(0); +x_26 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_14, x_25, x_1, x_12, x_11); +lean_dec(x_1); +return x_26; +} +else +{ +lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_27 = lean_ctor_get(x_12, 0); +x_28 = lean_ctor_get_uint8(x_12, sizeof(void*)*1); +lean_inc(x_27); +lean_dec(x_12); +x_29 = lean_array_push(x_27, x_21); +x_30 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set_uint8(x_30, sizeof(void*)*1, x_28); +x_31 = lean_box(0); +x_32 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_14, x_31, x_1, x_30, x_11); +lean_dec(x_1); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; +lean_dec(x_13); +x_33 = lean_box(0); +x_34 = l_Lake_buildFileAfterDep___rarg___lambda__2(x_14, x_33, x_1, x_12, x_11); +lean_dec(x_1); +return x_34; +} +} +else +{ +uint8_t x_35; +lean_dec(x_1); +x_35 = !lean_is_exclusive(x_8); +if (x_35 == 0) +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_8, 0); +lean_dec(x_36); +x_37 = !lean_is_exclusive(x_9); +if (x_37 == 0) +{ +return x_8; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_9, 0); +x_39 = lean_ctor_get(x_9, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_9); +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +lean_ctor_set(x_8, 0, x_40); +return x_8; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_41 = lean_ctor_get(x_8, 1); +lean_inc(x_41); +lean_dec(x_8); +x_42 = lean_ctor_get(x_9, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_9, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_44 = x_9; +} else { + lean_dec_ref(x_9); + x_44 = lean_box(0); +} +if (lean_is_scalar(x_44)) { + x_45 = lean_alloc_ctor(1, 2, 0); +} else { + x_45 = x_44; +} +lean_ctor_set(x_45, 0, x_42); +lean_ctor_set(x_45, 1, x_43); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_41); +return x_46; +} +} +} +else +{ +uint8_t x_47; +lean_dec(x_1); +x_47 = !lean_is_exclusive(x_8); +if (x_47 == 0) +{ +return x_8; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_8, 0); +x_49 = lean_ctor_get(x_8, 1); +lean_inc(x_49); +lean_inc(x_48); +lean_dec(x_8); +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_48); +lean_ctor_set(x_50, 1, x_49); +return x_50; +} +} +} +} +else +{ +uint8_t x_101; +lean_dec(x_1); +x_101 = !lean_is_exclusive(x_2); +if (x_101 == 0) +{ +lean_object* x_102; +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_2); +lean_ctor_set(x_102, 1, x_3); +return x_102; +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_103 = lean_ctor_get(x_2, 0); +x_104 = lean_ctor_get(x_2, 1); +lean_inc(x_104); +lean_inc(x_103); +lean_dec(x_2); +x_105 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_105, 0, x_103); +lean_ctor_set(x_105, 1, x_104); +x_106 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_106, 0, x_105); +lean_ctor_set(x_106, 1, x_3); +return x_106; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_1); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; +x_5 = lean_ctor_get(x_1, 0); +x_6 = lean_ctor_get(x_1, 1); +x_7 = lean_alloc_closure((void*)(l_Lake_computeDynlibOfShared___lambda__2), 3, 1); +lean_closure_set(x_7, 0, x_2); +x_8 = l_Task_Priority_default; +x_9 = 0; +x_10 = lean_io_map_task(x_7, x_5, x_8, x_9, x_3); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_10, 0); +lean_ctor_set(x_1, 0, x_12); +lean_ctor_set(x_10, 0, x_1); +return x_10; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = lean_ctor_get(x_10, 0); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_10); +lean_ctor_set(x_1, 0, x_13); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_1); +lean_ctor_set(x_15, 1, x_14); +return x_15; +} +} +else +{ +uint8_t x_16; +lean_free_object(x_1); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_10); +if (x_16 == 0) +{ +return x_10; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_10, 0); +x_18 = lean_ctor_get(x_10, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_10); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; +x_20 = lean_ctor_get(x_1, 0); +x_21 = lean_ctor_get(x_1, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_1); +x_22 = lean_alloc_closure((void*)(l_Lake_computeDynlibOfShared___lambda__2), 3, 1); +lean_closure_set(x_22, 0, x_2); +x_23 = l_Task_Priority_default; +x_24 = 0; +x_25 = lean_io_map_task(x_22, x_20, x_23, x_24, x_3); +if (lean_obj_tag(x_25) == 0) +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_26 = lean_ctor_get(x_25, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_25, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_25)) { + lean_ctor_release(x_25, 0); + lean_ctor_release(x_25, 1); + x_28 = x_25; +} else { + lean_dec_ref(x_25); + x_28 = lean_box(0); +} +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_26); +lean_ctor_set(x_29, 1, x_21); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +return x_30; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_21); +x_31 = lean_ctor_get(x_25, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_25, 1); +lean_inc(x_32); +if (lean_is_exclusive(x_25)) { + lean_ctor_release(x_25, 0); + lean_ctor_release(x_25, 1); + x_33 = x_25; +} else { + lean_dec_ref(x_25); + x_33 = lean_box(0); +} +if (lean_is_scalar(x_33)) { + x_34 = lean_alloc_ctor(1, 2, 0); +} else { + x_34 = x_33; +} +lean_ctor_set(x_34, 0, x_31); +lean_ctor_set(x_34, 1, x_32); +return x_34; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_computeDynlibOfShared___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_computeDynlibOfShared___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Config_Monad(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Actions(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Common(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Config_Monad(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Actions(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_platformTrace___closed__1 = _init_l_Lake_platformTrace___closed__1(); +l_Lake_platformTrace___closed__2 = _init_l_Lake_platformTrace___closed__2(); +l_Lake_platformTrace = _init_l_Lake_platformTrace(); +l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1 = _init_l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__1); +l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2 = _init_l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__2); +l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__3 = _init_l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__3(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_toJsonBuildMetadata____x40_Lake_Build_Common___hyg_31____closed__3); +l_Lake_instToJsonBuildMetadata___closed__1 = _init_l_Lake_instToJsonBuildMetadata___closed__1(); +lean_mark_persistent(l_Lake_instToJsonBuildMetadata___closed__1); +l_Lake_instToJsonBuildMetadata = _init_l_Lake_instToJsonBuildMetadata(); +lean_mark_persistent(l_Lake_instToJsonBuildMetadata); +l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__1 = _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__1(); +lean_mark_persistent(l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__1); +l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__2 = _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__2(); +lean_mark_persistent(l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__2); +l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__3 = _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__3(); +lean_mark_persistent(l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__1___closed__3); +l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1 = _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1(); +lean_mark_persistent(l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__1); +l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2 = _init_l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2(); +lean_mark_persistent(l_Lean_Json_getObjValAs_x3f___at___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____spec__2___closed__2); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__1 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__1(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__1); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__2 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__2(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__2); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__3 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__3(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__3); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__4 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__4(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__4); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__5 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__5(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__5); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__6 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__6(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__6); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__7 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__7(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__7); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__8 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__8(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__8); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__9 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__9(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__9); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__10 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__10(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__10); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__11 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__11(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__11); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__12 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__12(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__12); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__13 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__13(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__13); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__14 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__14(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__14); +l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__15 = _init_l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__15(); +lean_mark_persistent(l___private_Lake_Build_Common_0__Lake_fromJsonBuildMetadata____x40_Lake_Build_Common___hyg_79____closed__15); +l_Lake_instFromJsonBuildMetadata___closed__1 = _init_l_Lake_instFromJsonBuildMetadata___closed__1(); +lean_mark_persistent(l_Lake_instFromJsonBuildMetadata___closed__1); +l_Lake_instFromJsonBuildMetadata = _init_l_Lake_instFromJsonBuildMetadata(); +lean_mark_persistent(l_Lake_instFromJsonBuildMetadata); +l_Lake_readTraceFile_x3f___closed__1 = _init_l_Lake_readTraceFile_x3f___closed__1(); +lean_mark_persistent(l_Lake_readTraceFile_x3f___closed__1); +l_Lake_readTraceFile_x3f___closed__2 = _init_l_Lake_readTraceFile_x3f___closed__2(); +lean_mark_persistent(l_Lake_readTraceFile_x3f___closed__2); +l_Lake_readTraceFile_x3f___closed__3 = _init_l_Lake_readTraceFile_x3f___closed__3(); +lean_mark_persistent(l_Lake_readTraceFile_x3f___closed__3); +l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1 = _init_l_Lake_buildUnlessUpToDate_x3f___rarg___lambda__1___closed__1(); +l_Lake_buildUnlessUpToDate_x3f___rarg___closed__1 = _init_l_Lake_buildUnlessUpToDate_x3f___rarg___closed__1(); +lean_mark_persistent(l_Lake_buildUnlessUpToDate_x3f___rarg___closed__1); +l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2 = _init_l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2(); +lean_mark_persistent(l_Lake_buildUnlessUpToDate_x3f___rarg___closed__2); +l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3 = _init_l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3(); +lean_mark_persistent(l_Lake_buildUnlessUpToDate_x3f___rarg___closed__3); +l_Lake_cacheFileHash___closed__1 = _init_l_Lake_cacheFileHash___closed__1(); +lean_mark_persistent(l_Lake_cacheFileHash___closed__1); +l_Lake_buildFileUnlessUpToDate___closed__1 = _init_l_Lake_buildFileUnlessUpToDate___closed__1(); +lean_mark_persistent(l_Lake_buildFileUnlessUpToDate___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__2 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__2(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__3 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__3(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__3); +l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__4 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__4(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__4); +l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1___closed__5); +l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1 = _init_l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1(); +lean_mark_persistent(l_Lake_buildFileAfterDep___rarg___lambda__3___closed__1); +l_Lake_inputBinFile___closed__1 = _init_l_Lake_inputBinFile___closed__1(); +lean_mark_persistent(l_Lake_inputBinFile___closed__1); +l_Lake_buildO___lambda__1___closed__1 = _init_l_Lake_buildO___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_buildO___lambda__1___closed__1); +l_Lake_buildO___lambda__1___closed__2 = _init_l_Lake_buildO___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_buildO___lambda__1___closed__2); +l_Lake_buildLeanO___lambda__4___closed__1 = _init_l_Lake_buildLeanO___lambda__4___closed__1(); +lean_mark_persistent(l_Lake_buildLeanO___lambda__4___closed__1); +l_Lake_buildLeanO___closed__1 = _init_l_Lake_buildLeanO___closed__1(); +lean_mark_persistent(l_Lake_buildLeanO___closed__1); +l_Lake_buildStaticLib___lambda__3___closed__1 = _init_l_Lake_buildStaticLib___lambda__3___closed__1(); +lean_mark_persistent(l_Lake_buildStaticLib___lambda__3___closed__1); +l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__1 = _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__1(); +lean_mark_persistent(l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__1); +l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__2 = _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__2(); +lean_mark_persistent(l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__2); +l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__3 = _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__3(); +lean_mark_persistent(l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__3); +l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__4 = _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__4(); +lean_mark_persistent(l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__4); +l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__5 = _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__5(); +lean_mark_persistent(l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__5); +l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__6 = _init_l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__6(); +lean_mark_persistent(l_Lake_buildLeanSharedLibOfStatic___lambda__3___closed__6); +l_Lake_computeDynlibOfShared___lambda__2___closed__1 = _init_l_Lake_computeDynlibOfShared___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_computeDynlibOfShared___lambda__2___closed__1); +l_Lake_computeDynlibOfShared___lambda__2___closed__2 = _init_l_Lake_computeDynlibOfShared___lambda__2___closed__2(); +lean_mark_persistent(l_Lake_computeDynlibOfShared___lambda__2___closed__2); +l_Lake_computeDynlibOfShared___lambda__2___closed__3 = _init_l_Lake_computeDynlibOfShared___lambda__2___closed__3(); +lean_mark_persistent(l_Lake_computeDynlibOfShared___lambda__2___closed__3); +l_Lake_computeDynlibOfShared___lambda__2___closed__4 = _init_l_Lake_computeDynlibOfShared___lambda__2___closed__4(); +lean_mark_persistent(l_Lake_computeDynlibOfShared___lambda__2___closed__4); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Data.c b/stage0/stdlib/Lake/Build/Data.c new file mode 100644 index 0000000000..626a3dc241 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Data.c @@ -0,0 +1,2339 @@ +// Lean compiler output +// Module: Lake.Build.Data +// Imports: Init Lake.Build.Key Lake.Util.Family +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8; +static lean_object* l_Lake_packageDataDecl___closed__24; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__15; +static lean_object* l_Lake_packageDataDecl___closed__25; +static lean_object* l_Lake_libraryDataDecl___closed__8; +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__8; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +static lean_object* l_Lake_packageDataDecl___closed__11; +static lean_object* l_Lake_targetDataDecl___closed__6; +static lean_object* l_Lake_moduleDataDecl___closed__1; +static lean_object* l_Lake_customDataDecl___closed__6; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__2; +static lean_object* l_Lake_customDataDecl___closed__9; +static lean_object* l_Lake_packageDataDecl___closed__16; +static lean_object* l_Lake_customDataDecl___closed__5; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__14; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__3; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__2; +static lean_object* l_Lake_packageDataDecl___closed__23; +LEAN_EXPORT lean_object* l_Lake_packageDataDecl; +static lean_object* l_Lake_targetDataDecl___closed__9; +lean_object* l_Lean_Syntax_getId(lean_object*); +static lean_object* l_Lake_packageDataDecl___closed__22; +static lean_object* l_Lake_customDataDecl___closed__10; +static lean_object* l_Lake_packageDataDecl___closed__6; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__5; +static lean_object* l_Lake_packageDataDecl___closed__19; +static lean_object* l_Lake_packageDataDecl___closed__5; +static lean_object* l_Lake_customDataDecl___closed__3; +static lean_object* l_Lake_packageDataDecl___closed__21; +lean_object* l_Lean_mkIdentFrom(lean_object*, lean_object*, uint8_t); +static lean_object* l_Lake_packageDataDecl___closed__18; +static lean_object* l_Lake_moduleDataDecl___closed__3; +uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_packageDataDecl___closed__2; +static lean_object* l_Lake_targetDataDecl___closed__3; +LEAN_EXPORT lean_object* l_Lake_customDataDecl; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10; +static lean_object* l_Lake_libraryDataDecl___closed__9; +static lean_object* l_Lake_libraryDataDecl___closed__1; +static lean_object* l_Lake_packageDataDecl___closed__1; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__11; +static lean_object* l_Lake_packageDataDecl___closed__27; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__5; +static lean_object* l_Lake_moduleDataDecl___closed__6; +static lean_object* l_Lake_libraryDataDecl___closed__4; +static lean_object* l_Lake_targetDataDecl___closed__7; +static lean_object* l_Lake_moduleDataDecl___closed__8; +lean_object* l_Lean_SourceInfo_fromRef(lean_object*, uint8_t); +static lean_object* l_Lake_packageDataDecl___closed__4; +static lean_object* l_Lake_customDataDecl___closed__7; +static lean_object* l_Lake_packageDataDecl___closed__14; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17; +static lean_object* l_Lake_targetDataDecl___closed__4; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__4; +lean_object* l_Lean_mkCIdentFrom(lean_object*, lean_object*, uint8_t); +static lean_object* l_Lake_packageDataDecl___closed__20; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_object* l_Lean_Syntax_getOptional_x3f(lean_object*); +static lean_object* l_Lake_targetDataDecl___closed__5; +lean_object* l_Lean_Syntax_node3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_append(lean_object*, lean_object*); +static lean_object* l_Lake_packageDataDecl___closed__3; +lean_object* l_Lean_extractMacroScopes(lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__1; +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +static lean_object* l_Lake_targetDataDecl___closed__2; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__9; +static lean_object* l_Lake_libraryDataDecl___closed__2; +static lean_object* l_Lake_moduleDataDecl___closed__9; +lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*); +static lean_object* l_Lake_customDataDecl___closed__1; +static lean_object* l_Lake_packageDataDecl___closed__17; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__5; +static lean_object* l_Lake_packageDataDecl___closed__26; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9; +static lean_object* l_Lake_packageDataDecl___closed__12; +lean_object* l_Lean_MacroScopesView_review(lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__10; +static lean_object* l_Lake_packageDataDecl___closed__7; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__6; +static lean_object* l_Lake_packageDataDecl___closed__13; +static lean_object* l_Lake_customDataDecl___closed__8; +static lean_object* l_Lake_packageDataDecl___closed__28; +static lean_object* l_Lake_customDataDecl___closed__4; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__1; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__1; +static lean_object* l_Lake_targetDataDecl___closed__8; +uint8_t l_Lean_Name_hasMacroScopes(lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__1; +static lean_object* l_Lake_packageDataDecl___closed__29; +static lean_object* l_Lake_moduleDataDecl___closed__5; +static lean_object* l_Lake_moduleDataDecl___closed__4; +static lean_object* l_Lake_moduleDataDecl___closed__2; +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +static lean_object* l_Lake_libraryDataDecl___closed__7; +static lean_object* l_Lake_moduleDataDecl___closed__7; +LEAN_EXPORT lean_object* l_Lake_moduleDataDecl; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__12; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Syntax_node1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_libraryDataDecl; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_targetDataDecl; +static lean_object* l_Lake_packageDataDecl___closed__10; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__16; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__2; +static lean_object* l_Lake_libraryDataDecl___closed__3; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__4; +lean_object* l_Array_mkArray1___rarg(lean_object*); +static lean_object* l_Lake_customDataDecl___closed__2; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__targetDataDecl__1___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +static lean_object* l_Lake_packageDataDecl___closed__15; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__2; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__3; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__13; +lean_object* l_Lean_Syntax_node8(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_targetDataDecl___closed__1; +lean_object* l_Lean_Name_mkStr4(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__7; +static lean_object* l_Lake_packageDataDecl___closed__9; +static lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3; +static lean_object* l_Lake_libraryDataDecl___closed__6; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_packageDataDecl___closed__8; +lean_object* l_Lake_Name_quoteFrom(lean_object*, lean_object*); +static lean_object* l_Lake_libraryDataDecl___closed__5; +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__targetDataDecl__1(lean_object*, lean_object*, lean_object*); +static lean_object* _init_l_Lake_packageDataDecl___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("packageDataDecl", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake_packageDataDecl___closed__2; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("andthen", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_packageDataDecl___closed__4; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("optional", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_packageDataDecl___closed__6; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lean", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Parser", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Command", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__11() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("docComment", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_1 = l_Lake_packageDataDecl___closed__8; +x_2 = l_Lake_packageDataDecl___closed__9; +x_3 = l_Lake_packageDataDecl___closed__10; +x_4 = l_Lake_packageDataDecl___closed__11; +x_5 = l_Lean_Name_mkStr4(x_1, x_2, x_3, x_4); +return x_5; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_packageDataDecl___closed__12; +x_2 = lean_alloc_ctor(8, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__7; +x_2 = l_Lake_packageDataDecl___closed__13; +x_3 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__15() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("package_data ", 13); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__16() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_packageDataDecl___closed__15; +x_2 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__14; +x_3 = l_Lake_packageDataDecl___closed__16; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__18() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("ident", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__19() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_packageDataDecl___closed__18; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__20() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_packageDataDecl___closed__19; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__21() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__17; +x_3 = l_Lake_packageDataDecl___closed__20; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__22() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" : ", 3); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__23() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_packageDataDecl___closed__22; +x_2 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__24() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__21; +x_3 = l_Lake_packageDataDecl___closed__23; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__25() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("term", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__26() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_packageDataDecl___closed__25; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__27() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__26; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__28() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__24; +x_3 = l_Lake_packageDataDecl___closed__27; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_packageDataDecl___closed__29() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__3; +x_2 = lean_unsigned_to_nat(1022u); +x_3 = l_Lake_packageDataDecl___closed__28; +x_4 = lean_alloc_ctor(3, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_packageDataDecl() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_packageDataDecl___closed__29; +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("PackageData", 11); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("familyDef", 9); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__3; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("null", 4); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__5; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("family_def", 10); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":", 1); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":=", 2); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_2 = l_Array_append___rarg(x_1, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = l_Lake_packageDataDecl___closed__3; +lean_inc(x_1); +x_5 = l_Lean_Syntax_isOfKind(x_1, x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_1); +x_6 = lean_box(1); +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_44; +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_Syntax_getArg(x_1, x_8); +x_10 = lean_unsigned_to_nat(2u); +x_11 = l_Lean_Syntax_getArg(x_1, x_10); +x_12 = lean_unsigned_to_nat(4u); +x_13 = l_Lean_Syntax_getArg(x_1, x_12); +lean_dec(x_1); +x_44 = l_Lean_Syntax_getOptional_x3f(x_9); +lean_dec(x_9); +if (lean_obj_tag(x_44) == 0) +{ +lean_object* x_45; +x_45 = lean_box(0); +x_14 = x_45; +goto block_43; +} +else +{ +uint8_t x_46; +x_46 = !lean_is_exclusive(x_44); +if (x_46 == 0) +{ +x_14 = x_44; +goto block_43; +} +else +{ +lean_object* x_47; lean_object* x_48; +x_47 = lean_ctor_get(x_44, 0); +lean_inc(x_47); +lean_dec(x_44); +x_48 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_14 = x_48; +goto block_43; +} +} +block_43: +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_15 = lean_ctor_get(x_2, 5); +x_16 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__2; +x_17 = 0; +x_18 = l_Lean_mkCIdentFrom(x_15, x_16, x_17); +x_19 = l_Lean_Syntax_getId(x_11); +x_20 = l_Lake_Name_quoteFrom(x_11, x_19); +x_21 = l_Lean_SourceInfo_fromRef(x_15, x_17); +x_22 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8; +lean_inc(x_21); +x_23 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +x_24 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9; +lean_inc(x_21); +x_25 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_25, 0, x_21); +lean_ctor_set(x_25, 1, x_24); +x_26 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10; +lean_inc(x_21); +x_27 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_27, 0, x_21); +lean_ctor_set(x_27, 1, x_26); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +x_29 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +lean_inc(x_21); +x_30 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_30, 0, x_21); +lean_ctor_set(x_30, 1, x_28); +lean_ctor_set(x_30, 2, x_29); +x_31 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_32 = l_Lean_Syntax_node8(x_21, x_31, x_30, x_23, x_11, x_25, x_18, x_20, x_27, x_13); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_3); +return x_33; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_34 = lean_ctor_get(x_14, 0); +lean_inc(x_34); +lean_dec(x_14); +x_35 = l_Array_mkArray1___rarg(x_34); +x_36 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_37 = l_Array_append___rarg(x_36, x_35); +lean_dec(x_35); +x_38 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_inc(x_21); +x_39 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_39, 0, x_21); +lean_ctor_set(x_39, 1, x_38); +lean_ctor_set(x_39, 2, x_37); +x_40 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_41 = l_Lean_Syntax_node8(x_21, x_40, x_39, x_23, x_11, x_25, x_18, x_20, x_27, x_13); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_3); +return x_42; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("moduleDataDecl", 14); +return x_1; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake_moduleDataDecl___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("module_data ", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_moduleDataDecl___closed__3; +x_2 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__14; +x_3 = l_Lake_moduleDataDecl___closed__4; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_moduleDataDecl___closed__5; +x_3 = l_Lake_packageDataDecl___closed__20; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_moduleDataDecl___closed__6; +x_3 = l_Lake_packageDataDecl___closed__23; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_moduleDataDecl___closed__7; +x_3 = l_Lake_packageDataDecl___closed__27; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_moduleDataDecl___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_moduleDataDecl___closed__2; +x_2 = lean_unsigned_to_nat(1022u); +x_3 = l_Lake_moduleDataDecl___closed__8; +x_4 = lean_alloc_ctor(3, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_moduleDataDecl() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_moduleDataDecl___closed__9; +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("ModuleData", 10); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = l_Lake_moduleDataDecl___closed__2; +lean_inc(x_1); +x_5 = l_Lean_Syntax_isOfKind(x_1, x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_1); +x_6 = lean_box(1); +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_44; +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_Syntax_getArg(x_1, x_8); +x_10 = lean_unsigned_to_nat(2u); +x_11 = l_Lean_Syntax_getArg(x_1, x_10); +x_12 = lean_unsigned_to_nat(4u); +x_13 = l_Lean_Syntax_getArg(x_1, x_12); +lean_dec(x_1); +x_44 = l_Lean_Syntax_getOptional_x3f(x_9); +lean_dec(x_9); +if (lean_obj_tag(x_44) == 0) +{ +lean_object* x_45; +x_45 = lean_box(0); +x_14 = x_45; +goto block_43; +} +else +{ +uint8_t x_46; +x_46 = !lean_is_exclusive(x_44); +if (x_46 == 0) +{ +x_14 = x_44; +goto block_43; +} +else +{ +lean_object* x_47; lean_object* x_48; +x_47 = lean_ctor_get(x_44, 0); +lean_inc(x_47); +lean_dec(x_44); +x_48 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_14 = x_48; +goto block_43; +} +} +block_43: +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_15 = lean_ctor_get(x_2, 5); +x_16 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__2; +x_17 = 0; +x_18 = l_Lean_mkCIdentFrom(x_15, x_16, x_17); +x_19 = l_Lean_Syntax_getId(x_11); +x_20 = l_Lake_Name_quoteFrom(x_11, x_19); +x_21 = l_Lean_SourceInfo_fromRef(x_15, x_17); +x_22 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8; +lean_inc(x_21); +x_23 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +x_24 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9; +lean_inc(x_21); +x_25 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_25, 0, x_21); +lean_ctor_set(x_25, 1, x_24); +x_26 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10; +lean_inc(x_21); +x_27 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_27, 0, x_21); +lean_ctor_set(x_27, 1, x_26); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +x_29 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +lean_inc(x_21); +x_30 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_30, 0, x_21); +lean_ctor_set(x_30, 1, x_28); +lean_ctor_set(x_30, 2, x_29); +x_31 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_32 = l_Lean_Syntax_node8(x_21, x_31, x_30, x_23, x_11, x_25, x_18, x_20, x_27, x_13); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_3); +return x_33; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_34 = lean_ctor_get(x_14, 0); +lean_inc(x_34); +lean_dec(x_14); +x_35 = l_Array_mkArray1___rarg(x_34); +x_36 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_37 = l_Array_append___rarg(x_36, x_35); +lean_dec(x_35); +x_38 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_inc(x_21); +x_39 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_39, 0, x_21); +lean_ctor_set(x_39, 1, x_38); +lean_ctor_set(x_39, 2, x_37); +x_40 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_41 = l_Lean_Syntax_node8(x_21, x_40, x_39, x_23, x_11, x_25, x_18, x_20, x_27, x_13); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_3); +return x_42; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("libraryDataDecl", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake_libraryDataDecl___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("library_data ", 13); +return x_1; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_libraryDataDecl___closed__3; +x_2 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__14; +x_3 = l_Lake_libraryDataDecl___closed__4; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_libraryDataDecl___closed__5; +x_3 = l_Lake_packageDataDecl___closed__20; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_libraryDataDecl___closed__6; +x_3 = l_Lake_packageDataDecl___closed__23; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_libraryDataDecl___closed__7; +x_3 = l_Lake_packageDataDecl___closed__27; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_libraryDataDecl___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_libraryDataDecl___closed__2; +x_2 = lean_unsigned_to_nat(1022u); +x_3 = l_Lake_libraryDataDecl___closed__8; +x_4 = lean_alloc_ctor(3, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_libraryDataDecl() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_libraryDataDecl___closed__9; +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("TargetData", 10); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Term", 4); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("paren", 5); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_1 = l_Lake_packageDataDecl___closed__8; +x_2 = l_Lake_packageDataDecl___closed__9; +x_3 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__4; +x_5 = l_Lean_Name_mkStr4(x_1, x_2, x_3, x_4); +return x_5; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("(", 1); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("term_++_", 8); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__7; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("quotedName", 10); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_1 = l_Lake_packageDataDecl___closed__8; +x_2 = l_Lake_packageDataDecl___closed__9; +x_3 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__9; +x_5 = l_Lean_Name_mkStr4(x_1, x_2, x_3, x_4); +return x_5; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__11() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("name", 4); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__11; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__13() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("`leanLib", 8); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__14() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("++", 2); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__15() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(")", 1); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__16() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanLib", 7); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__16; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = l_Lake_libraryDataDecl___closed__2; +lean_inc(x_1); +x_5 = l_Lean_Syntax_isOfKind(x_1, x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_1); +x_6 = lean_box(1); +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_113; +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_Syntax_getArg(x_1, x_8); +x_10 = lean_unsigned_to_nat(2u); +x_11 = l_Lean_Syntax_getArg(x_1, x_10); +x_12 = lean_unsigned_to_nat(4u); +x_13 = l_Lean_Syntax_getArg(x_1, x_12); +lean_dec(x_1); +x_113 = l_Lean_Syntax_getOptional_x3f(x_9); +lean_dec(x_9); +if (lean_obj_tag(x_113) == 0) +{ +lean_object* x_114; +x_114 = lean_box(0); +x_14 = x_114; +goto block_112; +} +else +{ +uint8_t x_115; +x_115 = !lean_is_exclusive(x_113); +if (x_115 == 0) +{ +x_14 = x_113; +goto block_112; +} +else +{ +lean_object* x_116; lean_object* x_117; +x_116 = lean_ctor_get(x_113, 0); +lean_inc(x_116); +lean_dec(x_113); +x_117 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_117, 0, x_116); +x_14 = x_117; +goto block_112; +} +} +block_112: +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_15 = lean_ctor_get(x_2, 5); +x_16 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__2; +x_17 = 0; +x_18 = l_Lean_mkCIdentFrom(x_15, x_16, x_17); +x_19 = l_Lean_Syntax_getId(x_11); +lean_inc(x_19); +x_20 = l_Lake_Name_quoteFrom(x_11, x_19); +x_21 = l_Lean_Name_hasMacroScopes(x_19); +x_22 = l_Lean_SourceInfo_fromRef(x_15, x_17); +x_23 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8; +lean_inc(x_22); +x_24 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +x_25 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9; +lean_inc(x_22); +x_26 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_26, 0, x_22); +lean_ctor_set(x_26, 1, x_25); +x_27 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__6; +lean_inc(x_22); +x_28 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_28, 0, x_22); +lean_ctor_set(x_28, 1, x_27); +x_29 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__13; +lean_inc(x_22); +x_30 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_30, 0, x_22); +lean_ctor_set(x_30, 1, x_29); +x_31 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__12; +lean_inc(x_22); +x_32 = l_Lean_Syntax_node1(x_22, x_31, x_30); +x_33 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__10; +lean_inc(x_22); +x_34 = l_Lean_Syntax_node1(x_22, x_33, x_32); +x_35 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__14; +lean_inc(x_22); +x_36 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_36, 0, x_22); +lean_ctor_set(x_36, 1, x_35); +x_37 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__8; +lean_inc(x_22); +x_38 = l_Lean_Syntax_node3(x_22, x_37, x_34, x_36, x_20); +x_39 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__15; +lean_inc(x_22); +x_40 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_40, 0, x_22); +lean_ctor_set(x_40, 1, x_39); +x_41 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__5; +lean_inc(x_22); +x_42 = l_Lean_Syntax_node3(x_22, x_41, x_28, x_38, x_40); +x_43 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10; +lean_inc(x_22); +x_44 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_44, 0, x_22); +lean_ctor_set(x_44, 1, x_43); +if (x_21 == 0) +{ +lean_object* x_45; lean_object* x_46; uint8_t x_47; lean_object* x_48; +x_45 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17; +x_46 = l_Lean_Name_append(x_45, x_19); +x_47 = 1; +x_48 = l_Lean_mkIdentFrom(x_11, x_46, x_47); +lean_dec(x_11); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_49 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +x_50 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +lean_inc(x_22); +x_51 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_51, 0, x_22); +lean_ctor_set(x_51, 1, x_49); +lean_ctor_set(x_51, 2, x_50); +x_52 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_53 = l_Lean_Syntax_node8(x_22, x_52, x_51, x_24, x_48, x_26, x_18, x_42, x_44, x_13); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_3); +return x_54; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_55 = lean_ctor_get(x_14, 0); +lean_inc(x_55); +lean_dec(x_14); +x_56 = l_Array_mkArray1___rarg(x_55); +x_57 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_58 = l_Array_append___rarg(x_57, x_56); +lean_dec(x_56); +x_59 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_inc(x_22); +x_60 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_60, 0, x_22); +lean_ctor_set(x_60, 1, x_59); +lean_ctor_set(x_60, 2, x_58); +x_61 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_62 = l_Lean_Syntax_node8(x_22, x_61, x_60, x_24, x_48, x_26, x_18, x_42, x_44, x_13); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_3); +return x_63; +} +} +else +{ +lean_object* x_64; uint8_t x_65; +x_64 = l_Lean_extractMacroScopes(x_19); +x_65 = !lean_is_exclusive(x_64); +if (x_65 == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; +x_66 = lean_ctor_get(x_64, 0); +x_67 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17; +x_68 = l_Lean_Name_append(x_67, x_66); +lean_ctor_set(x_64, 0, x_68); +x_69 = l_Lean_MacroScopesView_review(x_64); +x_70 = 1; +x_71 = l_Lean_mkIdentFrom(x_11, x_69, x_70); +lean_dec(x_11); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_72 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +x_73 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +lean_inc(x_22); +x_74 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_74, 0, x_22); +lean_ctor_set(x_74, 1, x_72); +lean_ctor_set(x_74, 2, x_73); +x_75 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_76 = l_Lean_Syntax_node8(x_22, x_75, x_74, x_24, x_71, x_26, x_18, x_42, x_44, x_13); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_3); +return x_77; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_78 = lean_ctor_get(x_14, 0); +lean_inc(x_78); +lean_dec(x_14); +x_79 = l_Array_mkArray1___rarg(x_78); +x_80 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_81 = l_Array_append___rarg(x_80, x_79); +lean_dec(x_79); +x_82 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_inc(x_22); +x_83 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_83, 0, x_22); +lean_ctor_set(x_83, 1, x_82); +lean_ctor_set(x_83, 2, x_81); +x_84 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_85 = l_Lean_Syntax_node8(x_22, x_84, x_83, x_24, x_71, x_26, x_18, x_42, x_44, x_13); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_3); +return x_86; +} +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; lean_object* x_96; +x_87 = lean_ctor_get(x_64, 0); +x_88 = lean_ctor_get(x_64, 1); +x_89 = lean_ctor_get(x_64, 2); +x_90 = lean_ctor_get(x_64, 3); +lean_inc(x_90); +lean_inc(x_89); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_64); +x_91 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17; +x_92 = l_Lean_Name_append(x_91, x_87); +x_93 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_88); +lean_ctor_set(x_93, 2, x_89); +lean_ctor_set(x_93, 3, x_90); +x_94 = l_Lean_MacroScopesView_review(x_93); +x_95 = 1; +x_96 = l_Lean_mkIdentFrom(x_11, x_94, x_95); +lean_dec(x_11); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; +x_97 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +x_98 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +lean_inc(x_22); +x_99 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_99, 0, x_22); +lean_ctor_set(x_99, 1, x_97); +lean_ctor_set(x_99, 2, x_98); +x_100 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_101 = l_Lean_Syntax_node8(x_22, x_100, x_99, x_24, x_96, x_26, x_18, x_42, x_44, x_13); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_3); +return x_102; +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_103 = lean_ctor_get(x_14, 0); +lean_inc(x_103); +lean_dec(x_14); +x_104 = l_Array_mkArray1___rarg(x_103); +x_105 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_106 = l_Array_append___rarg(x_105, x_104); +lean_dec(x_104); +x_107 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_inc(x_22); +x_108 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_108, 0, x_22); +lean_ctor_set(x_108, 1, x_107); +lean_ctor_set(x_108, 2, x_106); +x_109 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_110 = l_Lean_Syntax_node8(x_22, x_109, x_108, x_24, x_96, x_26, x_18, x_42, x_44, x_13); +x_111 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_111, 0, x_110); +lean_ctor_set(x_111, 1, x_3); +return x_111; +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("targetDataDecl", 14); +return x_1; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake_targetDataDecl___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("target_data ", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_targetDataDecl___closed__3; +x_2 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__14; +x_3 = l_Lake_targetDataDecl___closed__4; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_targetDataDecl___closed__5; +x_3 = l_Lake_packageDataDecl___closed__20; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_targetDataDecl___closed__6; +x_3 = l_Lake_packageDataDecl___closed__23; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_targetDataDecl___closed__7; +x_3 = l_Lake_packageDataDecl___closed__27; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_targetDataDecl___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_targetDataDecl___closed__2; +x_2 = lean_unsigned_to_nat(1022u); +x_3 = l_Lake_targetDataDecl___closed__8; +x_4 = lean_alloc_ctor(3, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_targetDataDecl() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_targetDataDecl___closed__9; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__targetDataDecl__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = l_Lake_targetDataDecl___closed__2; +lean_inc(x_1); +x_5 = l_Lean_Syntax_isOfKind(x_1, x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_1); +x_6 = lean_box(1); +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_44; +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_Syntax_getArg(x_1, x_8); +x_10 = lean_unsigned_to_nat(2u); +x_11 = l_Lean_Syntax_getArg(x_1, x_10); +x_12 = lean_unsigned_to_nat(4u); +x_13 = l_Lean_Syntax_getArg(x_1, x_12); +lean_dec(x_1); +x_44 = l_Lean_Syntax_getOptional_x3f(x_9); +lean_dec(x_9); +if (lean_obj_tag(x_44) == 0) +{ +lean_object* x_45; +x_45 = lean_box(0); +x_14 = x_45; +goto block_43; +} +else +{ +uint8_t x_46; +x_46 = !lean_is_exclusive(x_44); +if (x_46 == 0) +{ +x_14 = x_44; +goto block_43; +} +else +{ +lean_object* x_47; lean_object* x_48; +x_47 = lean_ctor_get(x_44, 0); +lean_inc(x_47); +lean_dec(x_44); +x_48 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_14 = x_48; +goto block_43; +} +} +block_43: +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_15 = lean_ctor_get(x_2, 5); +x_16 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__2; +x_17 = 0; +x_18 = l_Lean_mkCIdentFrom(x_15, x_16, x_17); +x_19 = l_Lean_Syntax_getId(x_11); +x_20 = l_Lake_Name_quoteFrom(x_11, x_19); +x_21 = l_Lean_SourceInfo_fromRef(x_15, x_17); +x_22 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8; +lean_inc(x_21); +x_23 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +x_24 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9; +lean_inc(x_21); +x_25 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_25, 0, x_21); +lean_ctor_set(x_25, 1, x_24); +x_26 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10; +lean_inc(x_21); +x_27 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_27, 0, x_21); +lean_ctor_set(x_27, 1, x_26); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +x_29 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +lean_inc(x_21); +x_30 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_30, 0, x_21); +lean_ctor_set(x_30, 1, x_28); +lean_ctor_set(x_30, 2, x_29); +x_31 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_32 = l_Lean_Syntax_node8(x_21, x_31, x_30, x_23, x_11, x_25, x_18, x_20, x_27, x_13); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_3); +return x_33; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_34 = lean_ctor_get(x_14, 0); +lean_inc(x_34); +lean_dec(x_14); +x_35 = l_Array_mkArray1___rarg(x_34); +x_36 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_37 = l_Array_append___rarg(x_36, x_35); +lean_dec(x_35); +x_38 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_inc(x_21); +x_39 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_39, 0, x_21); +lean_ctor_set(x_39, 1, x_38); +lean_ctor_set(x_39, 2, x_37); +x_40 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_41 = l_Lean_Syntax_node8(x_21, x_40, x_39, x_23, x_11, x_25, x_18, x_20, x_27, x_13); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_3); +return x_42; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__targetDataDecl__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__targetDataDecl__1(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("customDataDecl", 14); +return x_1; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake_customDataDecl___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("custom_data ", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_customDataDecl___closed__3; +x_2 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_packageDataDecl___closed__14; +x_3 = l_Lake_customDataDecl___closed__4; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_customDataDecl___closed__5; +x_3 = l_Lake_packageDataDecl___closed__20; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_customDataDecl___closed__6; +x_3 = l_Lake_packageDataDecl___closed__20; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_customDataDecl___closed__7; +x_3 = l_Lake_packageDataDecl___closed__23; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_packageDataDecl___closed__5; +x_2 = l_Lake_customDataDecl___closed__8; +x_3 = l_Lake_packageDataDecl___closed__27; +x_4 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_customDataDecl___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_customDataDecl___closed__2; +x_2 = lean_unsigned_to_nat(1022u); +x_3 = l_Lake_customDataDecl___closed__9; +x_4 = lean_alloc_ctor(3, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_customDataDecl() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_customDataDecl___closed__10; +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("CustomData", 10); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_packageDataDecl___closed__1; +x_2 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("tuple", 5); +return x_1; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_1 = l_Lake_packageDataDecl___closed__8; +x_2 = l_Lake_packageDataDecl___closed__9; +x_3 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__3; +x_5 = l_Lean_Name_mkStr4(x_1, x_2, x_3, x_4); +return x_5; +} +} +static lean_object* _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(",", 1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = l_Lake_customDataDecl___closed__2; +lean_inc(x_1); +x_5 = l_Lean_Syntax_isOfKind(x_1, x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_1); +x_6 = lean_box(1); +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_59; +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_Syntax_getArg(x_1, x_8); +x_10 = lean_unsigned_to_nat(2u); +x_11 = l_Lean_Syntax_getArg(x_1, x_10); +x_12 = lean_unsigned_to_nat(3u); +x_13 = l_Lean_Syntax_getArg(x_1, x_12); +x_14 = lean_unsigned_to_nat(5u); +x_15 = l_Lean_Syntax_getArg(x_1, x_14); +lean_dec(x_1); +x_59 = l_Lean_Syntax_getOptional_x3f(x_9); +lean_dec(x_9); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; +x_60 = lean_box(0); +x_16 = x_60; +goto block_58; +} +else +{ +uint8_t x_61; +x_61 = !lean_is_exclusive(x_59); +if (x_61 == 0) +{ +x_16 = x_59; +goto block_58; +} +else +{ +lean_object* x_62; lean_object* x_63; +x_62 = lean_ctor_get(x_59, 0); +lean_inc(x_62); +lean_dec(x_59); +x_63 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_63, 0, x_62); +x_16 = x_63; +goto block_58; +} +} +block_58: +{ +lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_17 = lean_ctor_get(x_2, 5); +x_18 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__2; +x_19 = 0; +x_20 = l_Lean_mkCIdentFrom(x_17, x_18, x_19); +x_21 = l_Lean_Syntax_getId(x_11); +x_22 = l_Lean_Syntax_getId(x_13); +lean_inc(x_22); +lean_inc(x_21); +x_23 = l_Lean_Name_append(x_21, x_22); +x_24 = l_Lean_mkIdentFrom(x_13, x_23, x_19); +lean_dec(x_13); +x_25 = l_Lake_Name_quoteFrom(x_11, x_21); +lean_dec(x_11); +x_26 = l_Lake_Name_quoteFrom(x_25, x_22); +x_27 = l_Lean_SourceInfo_fromRef(x_17, x_19); +x_28 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8; +lean_inc(x_27); +x_29 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +x_30 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9; +lean_inc(x_27); +x_31 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_31, 0, x_27); +lean_ctor_set(x_31, 1, x_30); +x_32 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__6; +lean_inc(x_27); +x_33 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_33, 0, x_27); +lean_ctor_set(x_33, 1, x_32); +x_34 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__5; +lean_inc(x_27); +x_35 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_35, 0, x_27); +lean_ctor_set(x_35, 1, x_34); +x_36 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6; +lean_inc(x_27); +x_37 = l_Lean_Syntax_node1(x_27, x_36, x_26); +lean_inc(x_27); +x_38 = l_Lean_Syntax_node3(x_27, x_36, x_25, x_35, x_37); +x_39 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__15; +lean_inc(x_27); +x_40 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_40, 0, x_27); +lean_ctor_set(x_40, 1, x_39); +x_41 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__4; +lean_inc(x_27); +x_42 = l_Lean_Syntax_node3(x_27, x_41, x_33, x_38, x_40); +x_43 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10; +lean_inc(x_27); +x_44 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_44, 0, x_27); +lean_ctor_set(x_44, 1, x_43); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_45 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11; +lean_inc(x_27); +x_46 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_46, 0, x_27); +lean_ctor_set(x_46, 1, x_36); +lean_ctor_set(x_46, 2, x_45); +x_47 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_48 = l_Lean_Syntax_node8(x_27, x_47, x_46, x_29, x_24, x_31, x_20, x_42, x_44, x_15); +x_49 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_3); +return x_49; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_50 = lean_ctor_get(x_16, 0); +lean_inc(x_50); +lean_dec(x_16); +x_51 = l_Array_mkArray1___rarg(x_50); +x_52 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7; +x_53 = l_Array_append___rarg(x_52, x_51); +lean_dec(x_51); +lean_inc(x_27); +x_54 = lean_alloc_ctor(1, 3, 0); +lean_ctor_set(x_54, 0, x_27); +lean_ctor_set(x_54, 1, x_36); +lean_ctor_set(x_54, 2, x_53); +x_55 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4; +x_56 = l_Lean_Syntax_node8(x_27, x_55, x_54, x_29, x_24, x_31, x_20, x_42, x_44, x_15); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_3); +return x_57; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Key(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Family(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Data(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Key(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Family(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_packageDataDecl___closed__1 = _init_l_Lake_packageDataDecl___closed__1(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__1); +l_Lake_packageDataDecl___closed__2 = _init_l_Lake_packageDataDecl___closed__2(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__2); +l_Lake_packageDataDecl___closed__3 = _init_l_Lake_packageDataDecl___closed__3(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__3); +l_Lake_packageDataDecl___closed__4 = _init_l_Lake_packageDataDecl___closed__4(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__4); +l_Lake_packageDataDecl___closed__5 = _init_l_Lake_packageDataDecl___closed__5(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__5); +l_Lake_packageDataDecl___closed__6 = _init_l_Lake_packageDataDecl___closed__6(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__6); +l_Lake_packageDataDecl___closed__7 = _init_l_Lake_packageDataDecl___closed__7(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__7); +l_Lake_packageDataDecl___closed__8 = _init_l_Lake_packageDataDecl___closed__8(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__8); +l_Lake_packageDataDecl___closed__9 = _init_l_Lake_packageDataDecl___closed__9(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__9); +l_Lake_packageDataDecl___closed__10 = _init_l_Lake_packageDataDecl___closed__10(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__10); +l_Lake_packageDataDecl___closed__11 = _init_l_Lake_packageDataDecl___closed__11(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__11); +l_Lake_packageDataDecl___closed__12 = _init_l_Lake_packageDataDecl___closed__12(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__12); +l_Lake_packageDataDecl___closed__13 = _init_l_Lake_packageDataDecl___closed__13(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__13); +l_Lake_packageDataDecl___closed__14 = _init_l_Lake_packageDataDecl___closed__14(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__14); +l_Lake_packageDataDecl___closed__15 = _init_l_Lake_packageDataDecl___closed__15(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__15); +l_Lake_packageDataDecl___closed__16 = _init_l_Lake_packageDataDecl___closed__16(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__16); +l_Lake_packageDataDecl___closed__17 = _init_l_Lake_packageDataDecl___closed__17(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__17); +l_Lake_packageDataDecl___closed__18 = _init_l_Lake_packageDataDecl___closed__18(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__18); +l_Lake_packageDataDecl___closed__19 = _init_l_Lake_packageDataDecl___closed__19(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__19); +l_Lake_packageDataDecl___closed__20 = _init_l_Lake_packageDataDecl___closed__20(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__20); +l_Lake_packageDataDecl___closed__21 = _init_l_Lake_packageDataDecl___closed__21(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__21); +l_Lake_packageDataDecl___closed__22 = _init_l_Lake_packageDataDecl___closed__22(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__22); +l_Lake_packageDataDecl___closed__23 = _init_l_Lake_packageDataDecl___closed__23(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__23); +l_Lake_packageDataDecl___closed__24 = _init_l_Lake_packageDataDecl___closed__24(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__24); +l_Lake_packageDataDecl___closed__25 = _init_l_Lake_packageDataDecl___closed__25(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__25); +l_Lake_packageDataDecl___closed__26 = _init_l_Lake_packageDataDecl___closed__26(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__26); +l_Lake_packageDataDecl___closed__27 = _init_l_Lake_packageDataDecl___closed__27(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__27); +l_Lake_packageDataDecl___closed__28 = _init_l_Lake_packageDataDecl___closed__28(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__28); +l_Lake_packageDataDecl___closed__29 = _init_l_Lake_packageDataDecl___closed__29(); +lean_mark_persistent(l_Lake_packageDataDecl___closed__29); +l_Lake_packageDataDecl = _init_l_Lake_packageDataDecl(); +lean_mark_persistent(l_Lake_packageDataDecl); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__1 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__1(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__1); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__2 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__2(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__2); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__3 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__3(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__3); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__4); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__5 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__5(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__5); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__6); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__7); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__8); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__9); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__10); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__packageDataDecl__1___closed__11); +l_Lake_moduleDataDecl___closed__1 = _init_l_Lake_moduleDataDecl___closed__1(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__1); +l_Lake_moduleDataDecl___closed__2 = _init_l_Lake_moduleDataDecl___closed__2(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__2); +l_Lake_moduleDataDecl___closed__3 = _init_l_Lake_moduleDataDecl___closed__3(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__3); +l_Lake_moduleDataDecl___closed__4 = _init_l_Lake_moduleDataDecl___closed__4(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__4); +l_Lake_moduleDataDecl___closed__5 = _init_l_Lake_moduleDataDecl___closed__5(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__5); +l_Lake_moduleDataDecl___closed__6 = _init_l_Lake_moduleDataDecl___closed__6(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__6); +l_Lake_moduleDataDecl___closed__7 = _init_l_Lake_moduleDataDecl___closed__7(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__7); +l_Lake_moduleDataDecl___closed__8 = _init_l_Lake_moduleDataDecl___closed__8(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__8); +l_Lake_moduleDataDecl___closed__9 = _init_l_Lake_moduleDataDecl___closed__9(); +lean_mark_persistent(l_Lake_moduleDataDecl___closed__9); +l_Lake_moduleDataDecl = _init_l_Lake_moduleDataDecl(); +lean_mark_persistent(l_Lake_moduleDataDecl); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__1 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__1(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__1); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__2 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__2(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__moduleDataDecl__1___closed__2); +l_Lake_libraryDataDecl___closed__1 = _init_l_Lake_libraryDataDecl___closed__1(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__1); +l_Lake_libraryDataDecl___closed__2 = _init_l_Lake_libraryDataDecl___closed__2(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__2); +l_Lake_libraryDataDecl___closed__3 = _init_l_Lake_libraryDataDecl___closed__3(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__3); +l_Lake_libraryDataDecl___closed__4 = _init_l_Lake_libraryDataDecl___closed__4(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__4); +l_Lake_libraryDataDecl___closed__5 = _init_l_Lake_libraryDataDecl___closed__5(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__5); +l_Lake_libraryDataDecl___closed__6 = _init_l_Lake_libraryDataDecl___closed__6(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__6); +l_Lake_libraryDataDecl___closed__7 = _init_l_Lake_libraryDataDecl___closed__7(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__7); +l_Lake_libraryDataDecl___closed__8 = _init_l_Lake_libraryDataDecl___closed__8(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__8); +l_Lake_libraryDataDecl___closed__9 = _init_l_Lake_libraryDataDecl___closed__9(); +lean_mark_persistent(l_Lake_libraryDataDecl___closed__9); +l_Lake_libraryDataDecl = _init_l_Lake_libraryDataDecl(); +lean_mark_persistent(l_Lake_libraryDataDecl); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__1 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__1(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__1); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__2 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__2(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__2); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__3); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__4 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__4(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__4); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__5 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__5(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__5); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__6 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__6(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__6); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__7 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__7(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__7); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__8 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__8(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__8); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__9 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__9(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__9); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__10 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__10(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__10); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__11 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__11(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__11); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__12 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__12(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__12); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__13 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__13(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__13); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__14 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__14(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__14); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__15 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__15(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__15); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__16 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__16(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__16); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__libraryDataDecl__1___closed__17); +l_Lake_targetDataDecl___closed__1 = _init_l_Lake_targetDataDecl___closed__1(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__1); +l_Lake_targetDataDecl___closed__2 = _init_l_Lake_targetDataDecl___closed__2(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__2); +l_Lake_targetDataDecl___closed__3 = _init_l_Lake_targetDataDecl___closed__3(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__3); +l_Lake_targetDataDecl___closed__4 = _init_l_Lake_targetDataDecl___closed__4(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__4); +l_Lake_targetDataDecl___closed__5 = _init_l_Lake_targetDataDecl___closed__5(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__5); +l_Lake_targetDataDecl___closed__6 = _init_l_Lake_targetDataDecl___closed__6(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__6); +l_Lake_targetDataDecl___closed__7 = _init_l_Lake_targetDataDecl___closed__7(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__7); +l_Lake_targetDataDecl___closed__8 = _init_l_Lake_targetDataDecl___closed__8(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__8); +l_Lake_targetDataDecl___closed__9 = _init_l_Lake_targetDataDecl___closed__9(); +lean_mark_persistent(l_Lake_targetDataDecl___closed__9); +l_Lake_targetDataDecl = _init_l_Lake_targetDataDecl(); +lean_mark_persistent(l_Lake_targetDataDecl); +l_Lake_customDataDecl___closed__1 = _init_l_Lake_customDataDecl___closed__1(); +lean_mark_persistent(l_Lake_customDataDecl___closed__1); +l_Lake_customDataDecl___closed__2 = _init_l_Lake_customDataDecl___closed__2(); +lean_mark_persistent(l_Lake_customDataDecl___closed__2); +l_Lake_customDataDecl___closed__3 = _init_l_Lake_customDataDecl___closed__3(); +lean_mark_persistent(l_Lake_customDataDecl___closed__3); +l_Lake_customDataDecl___closed__4 = _init_l_Lake_customDataDecl___closed__4(); +lean_mark_persistent(l_Lake_customDataDecl___closed__4); +l_Lake_customDataDecl___closed__5 = _init_l_Lake_customDataDecl___closed__5(); +lean_mark_persistent(l_Lake_customDataDecl___closed__5); +l_Lake_customDataDecl___closed__6 = _init_l_Lake_customDataDecl___closed__6(); +lean_mark_persistent(l_Lake_customDataDecl___closed__6); +l_Lake_customDataDecl___closed__7 = _init_l_Lake_customDataDecl___closed__7(); +lean_mark_persistent(l_Lake_customDataDecl___closed__7); +l_Lake_customDataDecl___closed__8 = _init_l_Lake_customDataDecl___closed__8(); +lean_mark_persistent(l_Lake_customDataDecl___closed__8); +l_Lake_customDataDecl___closed__9 = _init_l_Lake_customDataDecl___closed__9(); +lean_mark_persistent(l_Lake_customDataDecl___closed__9); +l_Lake_customDataDecl___closed__10 = _init_l_Lake_customDataDecl___closed__10(); +lean_mark_persistent(l_Lake_customDataDecl___closed__10); +l_Lake_customDataDecl = _init_l_Lake_customDataDecl(); +lean_mark_persistent(l_Lake_customDataDecl); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__1 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__1(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__1); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__2 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__2(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__2); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__3 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__3(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__3); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__4 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__4(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__4); +l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__5 = _init_l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__5(); +lean_mark_persistent(l_Lake___aux__Lake__Build__Data______macroRules__Lake__customDataDecl__1___closed__5); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Executable.c b/stage0/stdlib/Lake/Build/Executable.c new file mode 100644 index 0000000000..214e2e5fa2 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Executable.c @@ -0,0 +1,3211 @@ +// Lean compiler output +// Module: Lake.Build.Executable +// Imports: Init Lake.Build.Common +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_LeanExe_recBuildExe___lambda__1___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanExe_recBuildExe___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +lean_object* l_System_FilePath_join(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__2(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___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_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_System_FilePath_exeExtension; +lean_object* l_Lake_buildLeanExe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanExe_recBuildExe___closed__2; +static lean_object* l_Lake_LeanExe_recBuildExe___closed__4; +static lean_object* l_Lake_LeanExe_recBuildExe___closed__3; +lean_object* l_Lake_LeanExe_linkArgs(lean_object*); +static lean_object* l_Lake_LeanExe_recBuildExe___lambda__1___closed__3; +size_t lean_usize_of_nat(lean_object*); +static lean_object* l_Lake_LeanExe_recBuildExe___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_withRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanExe_recBuildExe___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_append(lean_object*, lean_object*); +lean_object* l_System_FilePath_addExtension(lean_object*, lean_object*); +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__4(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5(size_t, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanExe_recBuildExe___spec__3___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanExe_recBuildExe___spec__3(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanExe_recBuildExe___closed__1; +static lean_object* l_Lake_LeanExe_recBuildExe___lambda__1___closed__4; +size_t lean_usize_add(size_t, size_t); +lean_object* lean_array_uget(lean_object*, size_t); +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6(lean_object*, lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +lean_object* l_Lake_LeanExeConfig_toLeanLibConfig(lean_object*); +lean_object* lean_array_get_size(lean_object*); +uint8_t lean_usize_dec_lt(size_t, size_t); +LEAN_EXPORT lean_object* l_Lake_LeanExe_recBuildExe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___closed__1; +static lean_object* l_Lake_LeanExe_recBuildExe___lambda__1___closed__5; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; uint8_t x_55; +x_55 = lean_usize_dec_lt(x_4, x_3); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_5); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_11); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_array_uget(x_2, x_4); +lean_inc(x_1); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_1); +lean_ctor_set(x_60, 1, x_59); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_61 = lean_apply_6(x_6, x_60, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_61) == 0) +{ +lean_object* x_62; lean_object* x_63; +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +if (lean_obj_tag(x_63) == 0) +{ +lean_object* x_64; uint8_t x_65; +x_64 = lean_ctor_get(x_61, 1); +lean_inc(x_64); +lean_dec(x_61); +x_65 = !lean_is_exclusive(x_62); +if (x_65 == 0) +{ +lean_object* x_66; uint8_t x_67; +x_66 = lean_ctor_get(x_62, 0); +lean_dec(x_66); +x_67 = !lean_is_exclusive(x_63); +if (x_67 == 0) +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_63, 0); +x_69 = lean_array_push(x_5, x_68); +x_70 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_63, 0, x_70); +x_12 = x_62; +x_13 = x_64; +goto block_54; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_71 = lean_ctor_get(x_63, 0); +x_72 = lean_ctor_get(x_63, 1); +lean_inc(x_72); +lean_inc(x_71); +lean_dec(x_63); +x_73 = lean_array_push(x_5, x_71); +x_74 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_74, 0, x_73); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_72); +lean_ctor_set(x_62, 0, x_75); +x_12 = x_62; +x_13 = x_64; +goto block_54; +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_76 = lean_ctor_get(x_62, 1); +lean_inc(x_76); +lean_dec(x_62); +x_77 = lean_ctor_get(x_63, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_63, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_79 = x_63; +} else { + lean_dec_ref(x_63); + x_79 = lean_box(0); +} +x_80 = lean_array_push(x_5, x_77); +x_81 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_81, 0, x_80); +if (lean_is_scalar(x_79)) { + x_82 = lean_alloc_ctor(0, 2, 0); +} else { + x_82 = x_79; +} +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_78); +x_83 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_76); +x_12 = x_83; +x_13 = x_64; +goto block_54; +} +} +else +{ +lean_object* x_84; uint8_t x_85; +lean_dec(x_5); +x_84 = lean_ctor_get(x_61, 1); +lean_inc(x_84); +lean_dec(x_61); +x_85 = !lean_is_exclusive(x_62); +if (x_85 == 0) +{ +lean_object* x_86; uint8_t x_87; +x_86 = lean_ctor_get(x_62, 0); +lean_dec(x_86); +x_87 = !lean_is_exclusive(x_63); +if (x_87 == 0) +{ +x_12 = x_62; +x_13 = x_84; +goto block_54; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_63, 0); +x_89 = lean_ctor_get(x_63, 1); +lean_inc(x_89); +lean_inc(x_88); +lean_dec(x_63); +x_90 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_90, 0, x_88); +lean_ctor_set(x_90, 1, x_89); +lean_ctor_set(x_62, 0, x_90); +x_12 = x_62; +x_13 = x_84; +goto block_54; +} +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_91 = lean_ctor_get(x_62, 1); +lean_inc(x_91); +lean_dec(x_62); +x_92 = lean_ctor_get(x_63, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_63, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_94 = x_63; +} else { + lean_dec_ref(x_63); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_91); +x_12 = x_96; +x_13 = x_84; +goto block_54; +} +} +} +else +{ +uint8_t x_97; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_97 = !lean_is_exclusive(x_61); +if (x_97 == 0) +{ +return x_61; +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_98 = lean_ctor_get(x_61, 0); +x_99 = lean_ctor_get(x_61, 1); +lean_inc(x_99); +lean_inc(x_98); +lean_dec(x_61); +x_100 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_99); +return x_100; +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__2(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; uint8_t x_55; +x_55 = lean_usize_dec_lt(x_4, x_3); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_5); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_11); +return x_58; +} +else +{ +lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; size_t x_67; size_t x_68; lean_object* x_69; +x_59 = lean_array_uget(x_2, x_4); +x_60 = lean_ctor_get_uint8(x_1, sizeof(void*)*7); +x_61 = lean_ctor_get(x_59, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_61, 1); +lean_inc(x_62); +lean_dec(x_61); +x_63 = lean_ctor_get(x_62, 8); +lean_inc(x_63); +lean_dec(x_62); +x_64 = lean_box(x_60); +x_65 = lean_apply_1(x_63, x_64); +x_66 = lean_array_get_size(x_65); +x_67 = lean_usize_of_nat(x_66); +lean_dec(x_66); +x_68 = 0; +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_69 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__1(x_59, x_65, x_67, x_68, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_65); +if (lean_obj_tag(x_69) == 0) +{ +lean_object* x_70; lean_object* x_71; +x_70 = lean_ctor_get(x_69, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_70, 0); +lean_inc(x_71); +if (lean_obj_tag(x_71) == 0) +{ +lean_object* x_72; uint8_t x_73; +x_72 = lean_ctor_get(x_69, 1); +lean_inc(x_72); +lean_dec(x_69); +x_73 = !lean_is_exclusive(x_70); +if (x_73 == 0) +{ +lean_object* x_74; uint8_t x_75; +x_74 = lean_ctor_get(x_70, 0); +lean_dec(x_74); +x_75 = !lean_is_exclusive(x_71); +if (x_75 == 0) +{ +lean_object* x_76; lean_object* x_77; +x_76 = lean_ctor_get(x_71, 0); +x_77 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_71, 0, x_77); +x_12 = x_70; +x_13 = x_72; +goto block_54; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_78 = lean_ctor_get(x_71, 0); +x_79 = lean_ctor_get(x_71, 1); +lean_inc(x_79); +lean_inc(x_78); +lean_dec(x_71); +x_80 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_80, 0, x_78); +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_79); +lean_ctor_set(x_70, 0, x_81); +x_12 = x_70; +x_13 = x_72; +goto block_54; +} +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_82 = lean_ctor_get(x_70, 1); +lean_inc(x_82); +lean_dec(x_70); +x_83 = lean_ctor_get(x_71, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_71, 1); +lean_inc(x_84); +if (lean_is_exclusive(x_71)) { + lean_ctor_release(x_71, 0); + lean_ctor_release(x_71, 1); + x_85 = x_71; +} else { + lean_dec_ref(x_71); + x_85 = lean_box(0); +} +x_86 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_86, 0, x_83); +if (lean_is_scalar(x_85)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_85; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_84); +x_88 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_82); +x_12 = x_88; +x_13 = x_72; +goto block_54; +} +} +else +{ +lean_object* x_89; uint8_t x_90; +x_89 = lean_ctor_get(x_69, 1); +lean_inc(x_89); +lean_dec(x_69); +x_90 = !lean_is_exclusive(x_70); +if (x_90 == 0) +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_70, 0); +lean_dec(x_91); +x_92 = !lean_is_exclusive(x_71); +if (x_92 == 0) +{ +x_12 = x_70; +x_13 = x_89; +goto block_54; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_93 = lean_ctor_get(x_71, 0); +x_94 = lean_ctor_get(x_71, 1); +lean_inc(x_94); +lean_inc(x_93); +lean_dec(x_71); +x_95 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_95, 0, x_93); +lean_ctor_set(x_95, 1, x_94); +lean_ctor_set(x_70, 0, x_95); +x_12 = x_70; +x_13 = x_89; +goto block_54; +} +} +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; +x_96 = lean_ctor_get(x_70, 1); +lean_inc(x_96); +lean_dec(x_70); +x_97 = lean_ctor_get(x_71, 0); +lean_inc(x_97); +x_98 = lean_ctor_get(x_71, 1); +lean_inc(x_98); +if (lean_is_exclusive(x_71)) { + lean_ctor_release(x_71, 0); + lean_ctor_release(x_71, 1); + x_99 = x_71; +} else { + lean_dec_ref(x_71); + x_99 = lean_box(0); +} +if (lean_is_scalar(x_99)) { + x_100 = lean_alloc_ctor(1, 2, 0); +} else { + x_100 = x_99; +} +lean_ctor_set(x_100, 0, x_97); +lean_ctor_set(x_100, 1, x_98); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_100); +lean_ctor_set(x_101, 1, x_96); +x_12 = x_101; +x_13 = x_89; +goto block_54; +} +} +} +else +{ +uint8_t x_102; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_102 = !lean_is_exclusive(x_69); +if (x_102 == 0) +{ +return x_69; +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; +x_103 = lean_ctor_get(x_69, 0); +x_104 = lean_ctor_get(x_69, 1); +lean_inc(x_104); +lean_inc(x_103); +lean_dec(x_69); +x_105 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_105, 0, x_103); +lean_ctor_set(x_105, 1, x_104); +return x_105; +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanExe_recBuildExe___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_3, 0); +x_5 = lean_ctor_get(x_3, 1); +x_6 = lean_ctor_get(x_3, 2); +x_7 = lean_ctor_get(x_3, 3); +lean_inc(x_1); +x_8 = l_Lean_RBNode_fold___at_Lake_LeanExe_recBuildExe___spec__3(x_1, x_2, x_4); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_5); +lean_ctor_set(x_9, 2, x_6); +x_10 = lean_array_push(x_8, x_9); +x_2 = x_10; +x_3 = x_7; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__4(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; uint8_t x_54; +x_54 = lean_usize_dec_lt(x_3, x_2); +if (x_54 == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_4); +lean_ctor_set(x_55, 1, x_8); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_array_uget(x_1, x_3); +x_59 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_59, 0, x_58); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_60 = lean_apply_6(x_5, x_59, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_60) == 0) +{ +lean_object* x_61; lean_object* x_62; +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +if (lean_obj_tag(x_62) == 0) +{ +lean_object* x_63; uint8_t x_64; +x_63 = lean_ctor_get(x_60, 1); +lean_inc(x_63); +lean_dec(x_60); +x_64 = !lean_is_exclusive(x_61); +if (x_64 == 0) +{ +lean_object* x_65; uint8_t x_66; +x_65 = lean_ctor_get(x_61, 0); +lean_dec(x_65); +x_66 = !lean_is_exclusive(x_62); +if (x_66 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_62, 0); +x_68 = lean_array_push(x_4, x_67); +x_69 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_62, 0, x_69); +x_11 = x_61; +x_12 = x_63; +goto block_53; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_70 = lean_ctor_get(x_62, 0); +x_71 = lean_ctor_get(x_62, 1); +lean_inc(x_71); +lean_inc(x_70); +lean_dec(x_62); +x_72 = lean_array_push(x_4, x_70); +x_73 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_73, 0, x_72); +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_71); +lean_ctor_set(x_61, 0, x_74); +x_11 = x_61; +x_12 = x_63; +goto block_53; +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_75 = lean_ctor_get(x_61, 1); +lean_inc(x_75); +lean_dec(x_61); +x_76 = lean_ctor_get(x_62, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_62, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_62)) { + lean_ctor_release(x_62, 0); + lean_ctor_release(x_62, 1); + x_78 = x_62; +} else { + lean_dec_ref(x_62); + x_78 = lean_box(0); +} +x_79 = lean_array_push(x_4, x_76); +x_80 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_80, 0, x_79); +if (lean_is_scalar(x_78)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_78; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_77); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_75); +x_11 = x_82; +x_12 = x_63; +goto block_53; +} +} +else +{ +lean_object* x_83; uint8_t x_84; +lean_dec(x_4); +x_83 = lean_ctor_get(x_60, 1); +lean_inc(x_83); +lean_dec(x_60); +x_84 = !lean_is_exclusive(x_61); +if (x_84 == 0) +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_61, 0); +lean_dec(x_85); +x_86 = !lean_is_exclusive(x_62); +if (x_86 == 0) +{ +x_11 = x_61; +x_12 = x_83; +goto block_53; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_62, 0); +x_88 = lean_ctor_get(x_62, 1); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_62); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +lean_ctor_set(x_61, 0, x_89); +x_11 = x_61; +x_12 = x_83; +goto block_53; +} +} +else +{ +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_90 = lean_ctor_get(x_61, 1); +lean_inc(x_90); +lean_dec(x_61); +x_91 = lean_ctor_get(x_62, 0); +lean_inc(x_91); +x_92 = lean_ctor_get(x_62, 1); +lean_inc(x_92); +if (lean_is_exclusive(x_62)) { + lean_ctor_release(x_62, 0); + lean_ctor_release(x_62, 1); + x_93 = x_62; +} else { + lean_dec_ref(x_62); + x_93 = lean_box(0); +} +if (lean_is_scalar(x_93)) { + x_94 = lean_alloc_ctor(1, 2, 0); +} else { + x_94 = x_93; +} +lean_ctor_set(x_94, 0, x_91); +lean_ctor_set(x_94, 1, x_92); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_90); +x_11 = x_95; +x_12 = x_83; +goto block_53; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_96 = !lean_is_exclusive(x_60); +if (x_96 == 0) +{ +return x_60; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_97 = lean_ctor_get(x_60, 0); +x_98 = lean_ctor_get(x_60, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_60); +x_99 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set(x_99, 1, x_98); +return x_99; +} +} +} +block_53: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; uint8_t x_17; +x_16 = lean_ctor_get(x_11, 0); +lean_dec(x_16); +x_17 = !lean_is_exclusive(x_13); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_13, 0); +lean_dec(x_18); +x_19 = lean_ctor_get(x_14, 0); +lean_inc(x_19); +lean_dec(x_14); +lean_ctor_set(x_13, 0, x_19); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_11); +lean_ctor_set(x_20, 1, x_12); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_13, 1); +lean_inc(x_21); +lean_dec(x_13); +x_22 = lean_ctor_get(x_14, 0); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_21); +lean_ctor_set(x_11, 0, x_23); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_11); +lean_ctor_set(x_24, 1, x_12); +return x_24; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_11, 1); +lean_inc(x_25); +lean_dec(x_11); +x_26 = lean_ctor_get(x_13, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_27 = x_13; +} else { + lean_dec_ref(x_13); + x_27 = lean_box(0); +} +x_28 = lean_ctor_get(x_14, 0); +lean_inc(x_28); +lean_dec(x_14); +if (lean_is_scalar(x_27)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_27; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_12); +return x_31; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; size_t x_35; size_t x_36; +x_32 = lean_ctor_get(x_11, 1); +lean_inc(x_32); +lean_dec(x_11); +x_33 = lean_ctor_get(x_13, 1); +lean_inc(x_33); +lean_dec(x_13); +x_34 = lean_ctor_get(x_14, 0); +lean_inc(x_34); +lean_dec(x_14); +x_35 = 1; +x_36 = lean_usize_add(x_3, x_35); +x_3 = x_36; +x_4 = x_34; +x_8 = x_33; +x_9 = x_32; +x_10 = x_12; +goto _start; +} +} +else +{ +uint8_t x_38; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_38 = !lean_is_exclusive(x_11); +if (x_38 == 0) +{ +lean_object* x_39; uint8_t x_40; +x_39 = lean_ctor_get(x_11, 0); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_13); +if (x_40 == 0) +{ +lean_object* x_41; +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_11); +lean_ctor_set(x_41, 1, x_12); +return x_41; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_42 = lean_ctor_get(x_13, 0); +x_43 = lean_ctor_get(x_13, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_13); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +lean_ctor_set(x_11, 0, x_44); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_11); +lean_ctor_set(x_45, 1, x_12); +return x_45; +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_46 = lean_ctor_get(x_11, 1); +lean_inc(x_46); +lean_dec(x_11); +x_47 = lean_ctor_get(x_13, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_13, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_49 = x_13; +} else { + lean_dec_ref(x_13); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_46); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_12); +return x_52; +} +} +} +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5(size_t x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; uint8_t x_55; +x_55 = lean_usize_dec_lt(x_4, x_3); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_5); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_11); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; size_t x_64; lean_object* x_65; +x_59 = lean_array_uget(x_2, x_4); +x_60 = lean_ctor_get(x_59, 10); +lean_inc(x_60); +x_61 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___closed__1; +x_62 = l_Lean_RBNode_fold___at_Lake_LeanExe_recBuildExe___spec__3(x_59, x_61, x_60); +lean_dec(x_60); +x_63 = lean_array_get_size(x_62); +x_64 = lean_usize_of_nat(x_63); +lean_dec(x_63); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_65 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__4(x_62, x_64, x_1, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_62); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; +x_66 = lean_ctor_get(x_65, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_66, 0); +lean_inc(x_67); +if (lean_obj_tag(x_67) == 0) +{ +lean_object* x_68; uint8_t x_69; +x_68 = lean_ctor_get(x_65, 1); +lean_inc(x_68); +lean_dec(x_65); +x_69 = !lean_is_exclusive(x_66); +if (x_69 == 0) +{ +lean_object* x_70; uint8_t x_71; +x_70 = lean_ctor_get(x_66, 0); +lean_dec(x_70); +x_71 = !lean_is_exclusive(x_67); +if (x_71 == 0) +{ +lean_object* x_72; lean_object* x_73; +x_72 = lean_ctor_get(x_67, 0); +x_73 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_67, 0, x_73); +x_12 = x_66; +x_13 = x_68; +goto block_54; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_74 = lean_ctor_get(x_67, 0); +x_75 = lean_ctor_get(x_67, 1); +lean_inc(x_75); +lean_inc(x_74); +lean_dec(x_67); +x_76 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_76, 0, x_74); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_75); +lean_ctor_set(x_66, 0, x_77); +x_12 = x_66; +x_13 = x_68; +goto block_54; +} +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_78 = lean_ctor_get(x_66, 1); +lean_inc(x_78); +lean_dec(x_66); +x_79 = lean_ctor_get(x_67, 0); +lean_inc(x_79); +x_80 = lean_ctor_get(x_67, 1); +lean_inc(x_80); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_81 = x_67; +} else { + lean_dec_ref(x_67); + x_81 = lean_box(0); +} +x_82 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_82, 0, x_79); +if (lean_is_scalar(x_81)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_81; +} +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_80); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_78); +x_12 = x_84; +x_13 = x_68; +goto block_54; +} +} +else +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_65, 1); +lean_inc(x_85); +lean_dec(x_65); +x_86 = !lean_is_exclusive(x_66); +if (x_86 == 0) +{ +lean_object* x_87; uint8_t x_88; +x_87 = lean_ctor_get(x_66, 0); +lean_dec(x_87); +x_88 = !lean_is_exclusive(x_67); +if (x_88 == 0) +{ +x_12 = x_66; +x_13 = x_85; +goto block_54; +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_89 = lean_ctor_get(x_67, 0); +x_90 = lean_ctor_get(x_67, 1); +lean_inc(x_90); +lean_inc(x_89); +lean_dec(x_67); +x_91 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set(x_91, 1, x_90); +lean_ctor_set(x_66, 0, x_91); +x_12 = x_66; +x_13 = x_85; +goto block_54; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_92 = lean_ctor_get(x_66, 1); +lean_inc(x_92); +lean_dec(x_66); +x_93 = lean_ctor_get(x_67, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_67, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_95 = x_67; +} else { + lean_dec_ref(x_67); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +x_97 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_97, 0, x_96); +lean_ctor_set(x_97, 1, x_92); +x_12 = x_97; +x_13 = x_85; +goto block_54; +} +} +} +else +{ +uint8_t x_98; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_98 = !lean_is_exclusive(x_65); +if (x_98 == 0) +{ +return x_65; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_65, 0); +x_100 = lean_ctor_get(x_65, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_65); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +return x_101; +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_3); +x_9 = lean_apply_6(x_1, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = lean_apply_7(x_2, x_14, x_3, x_4, x_5, x_15, x_13, x_12); +return x_16; +} +else +{ +uint8_t x_17; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_17 = !lean_is_exclusive(x_9); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_ctor_get(x_9, 0); +lean_dec(x_18); +x_19 = !lean_is_exclusive(x_10); +if (x_19 == 0) +{ +lean_object* x_20; uint8_t x_21; +x_20 = lean_ctor_get(x_10, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_11); +if (x_21 == 0) +{ +return x_9; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_11); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +lean_ctor_set(x_10, 0, x_24); +return x_9; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 1); +lean_inc(x_25); +lean_dec(x_10); +x_26 = lean_ctor_get(x_11, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_11, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_28 = x_11; +} else { + lean_dec_ref(x_11); + x_28 = lean_box(0); +} +if (lean_is_scalar(x_28)) { + x_29 = lean_alloc_ctor(1, 2, 0); +} else { + x_29 = x_28; +} +lean_ctor_set(x_29, 0, x_26); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 1); +lean_inc(x_32); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_33 = x_10; +} else { + lean_dec_ref(x_10); + x_33 = lean_box(0); +} +x_34 = lean_ctor_get(x_11, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_11, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_36 = x_11; +} else { + lean_dec_ref(x_11); + x_36 = lean_box(0); +} +if (lean_is_scalar(x_36)) { + x_37 = lean_alloc_ctor(1, 2, 0); +} else { + x_37 = x_36; +} +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_35); +if (lean_is_scalar(x_33)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_33; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_32); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_31); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +return x_9; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_9, 0); +x_42 = lean_ctor_get(x_9, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_9); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg), 8, 0); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("o", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanExe_recBuildExe___lambda__1___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("deps", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanExe_recBuildExe___lambda__1___closed__4; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExe_recBuildExe___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = l_Lake_LeanExe_recBuildExe___lambda__1___closed__2; +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_1); +lean_ctor_set(x_14, 1, x_13); +lean_inc(x_7); +lean_inc(x_9); +lean_inc(x_8); +x_15 = lean_apply_6(x_7, x_14, x_8, x_9, x_10, x_11, x_12); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; size_t x_25; size_t x_26; lean_object* x_27; +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_dec(x_17); +x_22 = l_Lake_LeanExe_recBuildExe___lambda__1___closed__3; +x_23 = lean_array_push(x_22, x_20); +x_24 = lean_array_get_size(x_6); +x_25 = lean_usize_of_nat(x_24); +lean_dec(x_24); +x_26 = 0; +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +x_27 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__2(x_2, x_6, x_25, x_26, x_23, x_7, x_8, x_9, x_21, x_19, x_18); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_30 = lean_ctor_get(x_27, 1); +lean_inc(x_30); +lean_dec(x_27); +x_31 = lean_ctor_get(x_28, 1); +lean_inc(x_31); +lean_dec(x_28); +x_32 = lean_ctor_get(x_29, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_29, 1); +lean_inc(x_33); +lean_dec(x_29); +x_34 = l_Lake_LeanExe_recBuildExe___lambda__1___closed__5; +lean_inc(x_3); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_3); +lean_ctor_set(x_35, 1, x_34); +lean_inc(x_7); +lean_inc(x_9); +lean_inc(x_8); +x_36 = lean_apply_6(x_7, x_35, x_8, x_9, x_33, x_31, x_30); +if (lean_obj_tag(x_36) == 0) +{ +lean_object* x_37; lean_object* x_38; +x_37 = lean_ctor_get(x_36, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_37, 0); +lean_inc(x_38); +if (lean_obj_tag(x_38) == 0) +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; size_t x_45; lean_object* x_46; +x_39 = lean_ctor_get(x_36, 1); +lean_inc(x_39); +lean_dec(x_36); +x_40 = lean_ctor_get(x_37, 1); +lean_inc(x_40); +lean_dec(x_37); +x_41 = lean_ctor_get(x_38, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_38, 1); +lean_inc(x_42); +lean_dec(x_38); +lean_inc(x_3); +x_43 = lean_array_push(x_41, x_3); +x_44 = lean_array_get_size(x_43); +x_45 = lean_usize_of_nat(x_44); +lean_dec(x_44); +lean_inc(x_9); +x_46 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5(x_26, x_43, x_45, x_26, x_32, x_7, x_8, x_9, x_42, x_40, x_39); +lean_dec(x_43); +if (lean_obj_tag(x_46) == 0) +{ +lean_object* x_47; lean_object* x_48; +x_47 = lean_ctor_get(x_46, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; uint8_t x_50; +x_49 = lean_ctor_get(x_46, 1); +lean_inc(x_49); +lean_dec(x_46); +x_50 = !lean_is_exclusive(x_47); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; uint8_t x_53; +x_51 = lean_ctor_get(x_47, 1); +x_52 = lean_ctor_get(x_47, 0); +lean_dec(x_52); +x_53 = !lean_is_exclusive(x_48); +if (x_53 == 0) +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_54 = lean_ctor_get(x_48, 0); +x_55 = lean_ctor_get(x_48, 1); +x_56 = lean_ctor_get(x_3, 0); +lean_inc(x_56); +lean_dec(x_3); +x_57 = lean_ctor_get(x_4, 8); +lean_inc(x_57); +x_58 = l_System_FilePath_join(x_56, x_57); +x_59 = lean_ctor_get(x_4, 11); +lean_inc(x_59); +x_60 = l_System_FilePath_join(x_58, x_59); +x_61 = lean_ctor_get(x_2, 4); +lean_inc(x_61); +x_62 = l_System_FilePath_exeExtension; +x_63 = l_System_FilePath_addExtension(x_61, x_62); +x_64 = l_System_FilePath_join(x_60, x_63); +x_65 = lean_ctor_get(x_4, 1); +lean_inc(x_65); +lean_dec(x_4); +x_66 = lean_ctor_get(x_65, 7); +lean_inc(x_66); +lean_dec(x_65); +x_67 = lean_ctor_get(x_2, 0); +lean_inc(x_67); +lean_dec(x_2); +x_68 = lean_ctor_get(x_67, 7); +lean_inc(x_68); +lean_dec(x_67); +x_69 = l_Array_append___rarg(x_66, x_68); +lean_dec(x_68); +x_70 = l_Lake_LeanExe_linkArgs(x_5); +x_71 = l_Lake_buildLeanExe(x_64, x_54, x_69, x_70, x_9, x_49); +lean_dec(x_54); +if (lean_obj_tag(x_71) == 0) +{ +uint8_t x_72; +x_72 = !lean_is_exclusive(x_71); +if (x_72 == 0) +{ +lean_object* x_73; +x_73 = lean_ctor_get(x_71, 0); +lean_ctor_set(x_48, 0, x_73); +lean_ctor_set(x_71, 0, x_47); +return x_71; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_71, 0); +x_75 = lean_ctor_get(x_71, 1); +lean_inc(x_75); +lean_inc(x_74); +lean_dec(x_71); +lean_ctor_set(x_48, 0, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_47); +lean_ctor_set(x_76, 1, x_75); +return x_76; +} +} +else +{ +uint8_t x_77; +lean_free_object(x_48); +lean_dec(x_55); +lean_free_object(x_47); +lean_dec(x_51); +x_77 = !lean_is_exclusive(x_71); +if (x_77 == 0) +{ +return x_71; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_78 = lean_ctor_get(x_71, 0); +x_79 = lean_ctor_get(x_71, 1); +lean_inc(x_79); +lean_inc(x_78); +lean_dec(x_71); +x_80 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set(x_80, 1, x_79); +return x_80; +} +} +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_81 = lean_ctor_get(x_48, 0); +x_82 = lean_ctor_get(x_48, 1); +lean_inc(x_82); +lean_inc(x_81); +lean_dec(x_48); +x_83 = lean_ctor_get(x_3, 0); +lean_inc(x_83); +lean_dec(x_3); +x_84 = lean_ctor_get(x_4, 8); +lean_inc(x_84); +x_85 = l_System_FilePath_join(x_83, x_84); +x_86 = lean_ctor_get(x_4, 11); +lean_inc(x_86); +x_87 = l_System_FilePath_join(x_85, x_86); +x_88 = lean_ctor_get(x_2, 4); +lean_inc(x_88); +x_89 = l_System_FilePath_exeExtension; +x_90 = l_System_FilePath_addExtension(x_88, x_89); +x_91 = l_System_FilePath_join(x_87, x_90); +x_92 = lean_ctor_get(x_4, 1); +lean_inc(x_92); +lean_dec(x_4); +x_93 = lean_ctor_get(x_92, 7); +lean_inc(x_93); +lean_dec(x_92); +x_94 = lean_ctor_get(x_2, 0); +lean_inc(x_94); +lean_dec(x_2); +x_95 = lean_ctor_get(x_94, 7); +lean_inc(x_95); +lean_dec(x_94); +x_96 = l_Array_append___rarg(x_93, x_95); +lean_dec(x_95); +x_97 = l_Lake_LeanExe_linkArgs(x_5); +x_98 = l_Lake_buildLeanExe(x_91, x_81, x_96, x_97, x_9, x_49); +lean_dec(x_81); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_99 = lean_ctor_get(x_98, 0); +lean_inc(x_99); +x_100 = lean_ctor_get(x_98, 1); +lean_inc(x_100); +if (lean_is_exclusive(x_98)) { + lean_ctor_release(x_98, 0); + lean_ctor_release(x_98, 1); + x_101 = x_98; +} else { + lean_dec_ref(x_98); + x_101 = lean_box(0); +} +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_99); +lean_ctor_set(x_102, 1, x_82); +lean_ctor_set(x_47, 0, x_102); +if (lean_is_scalar(x_101)) { + x_103 = lean_alloc_ctor(0, 2, 0); +} else { + x_103 = x_101; +} +lean_ctor_set(x_103, 0, x_47); +lean_ctor_set(x_103, 1, x_100); +return x_103; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_82); +lean_free_object(x_47); +lean_dec(x_51); +x_104 = lean_ctor_get(x_98, 0); +lean_inc(x_104); +x_105 = lean_ctor_get(x_98, 1); +lean_inc(x_105); +if (lean_is_exclusive(x_98)) { + lean_ctor_release(x_98, 0); + lean_ctor_release(x_98, 1); + x_106 = x_98; +} else { + lean_dec_ref(x_98); + x_106 = lean_box(0); +} +if (lean_is_scalar(x_106)) { + x_107 = lean_alloc_ctor(1, 2, 0); +} else { + x_107 = x_106; +} +lean_ctor_set(x_107, 0, x_104); +lean_ctor_set(x_107, 1, x_105); +return x_107; +} +} +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +x_108 = lean_ctor_get(x_47, 1); +lean_inc(x_108); +lean_dec(x_47); +x_109 = lean_ctor_get(x_48, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_48, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_111 = x_48; +} else { + lean_dec_ref(x_48); + x_111 = lean_box(0); +} +x_112 = lean_ctor_get(x_3, 0); +lean_inc(x_112); +lean_dec(x_3); +x_113 = lean_ctor_get(x_4, 8); +lean_inc(x_113); +x_114 = l_System_FilePath_join(x_112, x_113); +x_115 = lean_ctor_get(x_4, 11); +lean_inc(x_115); +x_116 = l_System_FilePath_join(x_114, x_115); +x_117 = lean_ctor_get(x_2, 4); +lean_inc(x_117); +x_118 = l_System_FilePath_exeExtension; +x_119 = l_System_FilePath_addExtension(x_117, x_118); +x_120 = l_System_FilePath_join(x_116, x_119); +x_121 = lean_ctor_get(x_4, 1); +lean_inc(x_121); +lean_dec(x_4); +x_122 = lean_ctor_get(x_121, 7); +lean_inc(x_122); +lean_dec(x_121); +x_123 = lean_ctor_get(x_2, 0); +lean_inc(x_123); +lean_dec(x_2); +x_124 = lean_ctor_get(x_123, 7); +lean_inc(x_124); +lean_dec(x_123); +x_125 = l_Array_append___rarg(x_122, x_124); +lean_dec(x_124); +x_126 = l_Lake_LeanExe_linkArgs(x_5); +x_127 = l_Lake_buildLeanExe(x_120, x_109, x_125, x_126, x_9, x_49); +lean_dec(x_109); +if (lean_obj_tag(x_127) == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; +x_128 = lean_ctor_get(x_127, 0); +lean_inc(x_128); +x_129 = lean_ctor_get(x_127, 1); +lean_inc(x_129); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + lean_ctor_release(x_127, 1); + x_130 = x_127; +} else { + lean_dec_ref(x_127); + x_130 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_131 = lean_alloc_ctor(0, 2, 0); +} else { + x_131 = x_111; +} +lean_ctor_set(x_131, 0, x_128); +lean_ctor_set(x_131, 1, x_110); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_108); +if (lean_is_scalar(x_130)) { + x_133 = lean_alloc_ctor(0, 2, 0); +} else { + x_133 = x_130; +} +lean_ctor_set(x_133, 0, x_132); +lean_ctor_set(x_133, 1, x_129); +return x_133; +} +else +{ +lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +lean_dec(x_111); +lean_dec(x_110); +lean_dec(x_108); +x_134 = lean_ctor_get(x_127, 0); +lean_inc(x_134); +x_135 = lean_ctor_get(x_127, 1); +lean_inc(x_135); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + lean_ctor_release(x_127, 1); + x_136 = x_127; +} else { + lean_dec_ref(x_127); + x_136 = lean_box(0); +} +if (lean_is_scalar(x_136)) { + x_137 = lean_alloc_ctor(1, 2, 0); +} else { + x_137 = x_136; +} +lean_ctor_set(x_137, 0, x_134); +lean_ctor_set(x_137, 1, x_135); +return x_137; +} +} +} +else +{ +uint8_t x_138; +lean_dec(x_9); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_138 = !lean_is_exclusive(x_46); +if (x_138 == 0) +{ +lean_object* x_139; uint8_t x_140; +x_139 = lean_ctor_get(x_46, 0); +lean_dec(x_139); +x_140 = !lean_is_exclusive(x_47); +if (x_140 == 0) +{ +lean_object* x_141; uint8_t x_142; +x_141 = lean_ctor_get(x_47, 0); +lean_dec(x_141); +x_142 = !lean_is_exclusive(x_48); +if (x_142 == 0) +{ +return x_46; +} +else +{ +lean_object* x_143; lean_object* x_144; lean_object* x_145; +x_143 = lean_ctor_get(x_48, 0); +x_144 = lean_ctor_get(x_48, 1); +lean_inc(x_144); +lean_inc(x_143); +lean_dec(x_48); +x_145 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_145, 0, x_143); +lean_ctor_set(x_145, 1, x_144); +lean_ctor_set(x_47, 0, x_145); +return x_46; +} +} +else +{ +lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_146 = lean_ctor_get(x_47, 1); +lean_inc(x_146); +lean_dec(x_47); +x_147 = lean_ctor_get(x_48, 0); +lean_inc(x_147); +x_148 = lean_ctor_get(x_48, 1); +lean_inc(x_148); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_149 = x_48; +} else { + lean_dec_ref(x_48); + x_149 = lean_box(0); +} +if (lean_is_scalar(x_149)) { + x_150 = lean_alloc_ctor(1, 2, 0); +} else { + x_150 = x_149; +} +lean_ctor_set(x_150, 0, x_147); +lean_ctor_set(x_150, 1, x_148); +x_151 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_151, 0, x_150); +lean_ctor_set(x_151, 1, x_146); +lean_ctor_set(x_46, 0, x_151); +return x_46; +} +} +else +{ +lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_152 = lean_ctor_get(x_46, 1); +lean_inc(x_152); +lean_dec(x_46); +x_153 = lean_ctor_get(x_47, 1); +lean_inc(x_153); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_154 = x_47; +} else { + lean_dec_ref(x_47); + x_154 = lean_box(0); +} +x_155 = lean_ctor_get(x_48, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_48, 1); +lean_inc(x_156); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_157 = x_48; +} else { + lean_dec_ref(x_48); + x_157 = lean_box(0); +} +if (lean_is_scalar(x_157)) { + x_158 = lean_alloc_ctor(1, 2, 0); +} else { + x_158 = x_157; +} +lean_ctor_set(x_158, 0, x_155); +lean_ctor_set(x_158, 1, x_156); +if (lean_is_scalar(x_154)) { + x_159 = lean_alloc_ctor(0, 2, 0); +} else { + x_159 = x_154; +} +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_153); +x_160 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +} +} +else +{ +uint8_t x_161; +lean_dec(x_9); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_161 = !lean_is_exclusive(x_46); +if (x_161 == 0) +{ +return x_46; +} +else +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_162 = lean_ctor_get(x_46, 0); +x_163 = lean_ctor_get(x_46, 1); +lean_inc(x_163); +lean_inc(x_162); +lean_dec(x_46); +x_164 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_164, 0, x_162); +lean_ctor_set(x_164, 1, x_163); +return x_164; +} +} +} +else +{ +uint8_t x_165; +lean_dec(x_32); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_165 = !lean_is_exclusive(x_36); +if (x_165 == 0) +{ +lean_object* x_166; uint8_t x_167; +x_166 = lean_ctor_get(x_36, 0); +lean_dec(x_166); +x_167 = !lean_is_exclusive(x_37); +if (x_167 == 0) +{ +lean_object* x_168; uint8_t x_169; +x_168 = lean_ctor_get(x_37, 0); +lean_dec(x_168); +x_169 = !lean_is_exclusive(x_38); +if (x_169 == 0) +{ +return x_36; +} +else +{ +lean_object* x_170; lean_object* x_171; lean_object* x_172; +x_170 = lean_ctor_get(x_38, 0); +x_171 = lean_ctor_get(x_38, 1); +lean_inc(x_171); +lean_inc(x_170); +lean_dec(x_38); +x_172 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_172, 0, x_170); +lean_ctor_set(x_172, 1, x_171); +lean_ctor_set(x_37, 0, x_172); +return x_36; +} +} +else +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; +x_173 = lean_ctor_get(x_37, 1); +lean_inc(x_173); +lean_dec(x_37); +x_174 = lean_ctor_get(x_38, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_38, 1); +lean_inc(x_175); +if (lean_is_exclusive(x_38)) { + lean_ctor_release(x_38, 0); + lean_ctor_release(x_38, 1); + x_176 = x_38; +} else { + lean_dec_ref(x_38); + x_176 = lean_box(0); +} +if (lean_is_scalar(x_176)) { + x_177 = lean_alloc_ctor(1, 2, 0); +} else { + x_177 = x_176; +} +lean_ctor_set(x_177, 0, x_174); +lean_ctor_set(x_177, 1, x_175); +x_178 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_173); +lean_ctor_set(x_36, 0, x_178); +return x_36; +} +} +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; +x_179 = lean_ctor_get(x_36, 1); +lean_inc(x_179); +lean_dec(x_36); +x_180 = lean_ctor_get(x_37, 1); +lean_inc(x_180); +if (lean_is_exclusive(x_37)) { + lean_ctor_release(x_37, 0); + lean_ctor_release(x_37, 1); + x_181 = x_37; +} else { + lean_dec_ref(x_37); + x_181 = lean_box(0); +} +x_182 = lean_ctor_get(x_38, 0); +lean_inc(x_182); +x_183 = lean_ctor_get(x_38, 1); +lean_inc(x_183); +if (lean_is_exclusive(x_38)) { + lean_ctor_release(x_38, 0); + lean_ctor_release(x_38, 1); + x_184 = x_38; +} else { + lean_dec_ref(x_38); + x_184 = lean_box(0); +} +if (lean_is_scalar(x_184)) { + x_185 = lean_alloc_ctor(1, 2, 0); +} else { + x_185 = x_184; +} +lean_ctor_set(x_185, 0, x_182); +lean_ctor_set(x_185, 1, x_183); +if (lean_is_scalar(x_181)) { + x_186 = lean_alloc_ctor(0, 2, 0); +} else { + x_186 = x_181; +} +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_180); +x_187 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_179); +return x_187; +} +} +} +else +{ +uint8_t x_188; +lean_dec(x_32); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_188 = !lean_is_exclusive(x_36); +if (x_188 == 0) +{ +return x_36; +} +else +{ +lean_object* x_189; lean_object* x_190; lean_object* x_191; +x_189 = lean_ctor_get(x_36, 0); +x_190 = lean_ctor_get(x_36, 1); +lean_inc(x_190); +lean_inc(x_189); +lean_dec(x_36); +x_191 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_191, 0, x_189); +lean_ctor_set(x_191, 1, x_190); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_192 = !lean_is_exclusive(x_27); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_27, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_28); +if (x_194 == 0) +{ +lean_object* x_195; uint8_t x_196; +x_195 = lean_ctor_get(x_28, 0); +lean_dec(x_195); +x_196 = !lean_is_exclusive(x_29); +if (x_196 == 0) +{ +return x_27; +} +else +{ +lean_object* x_197; lean_object* x_198; lean_object* x_199; +x_197 = lean_ctor_get(x_29, 0); +x_198 = lean_ctor_get(x_29, 1); +lean_inc(x_198); +lean_inc(x_197); +lean_dec(x_29); +x_199 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_199, 0, x_197); +lean_ctor_set(x_199, 1, x_198); +lean_ctor_set(x_28, 0, x_199); +return x_27; +} +} +else +{ +lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; +x_200 = lean_ctor_get(x_28, 1); +lean_inc(x_200); +lean_dec(x_28); +x_201 = lean_ctor_get(x_29, 0); +lean_inc(x_201); +x_202 = lean_ctor_get(x_29, 1); +lean_inc(x_202); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_203 = x_29; +} else { + lean_dec_ref(x_29); + x_203 = lean_box(0); +} +if (lean_is_scalar(x_203)) { + x_204 = lean_alloc_ctor(1, 2, 0); +} else { + x_204 = x_203; +} +lean_ctor_set(x_204, 0, x_201); +lean_ctor_set(x_204, 1, x_202); +x_205 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_205, 0, x_204); +lean_ctor_set(x_205, 1, x_200); +lean_ctor_set(x_27, 0, x_205); +return x_27; +} +} +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; +x_206 = lean_ctor_get(x_27, 1); +lean_inc(x_206); +lean_dec(x_27); +x_207 = lean_ctor_get(x_28, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_208 = x_28; +} else { + lean_dec_ref(x_28); + x_208 = lean_box(0); +} +x_209 = lean_ctor_get(x_29, 0); +lean_inc(x_209); +x_210 = lean_ctor_get(x_29, 1); +lean_inc(x_210); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_211 = x_29; +} else { + lean_dec_ref(x_29); + x_211 = lean_box(0); +} +if (lean_is_scalar(x_211)) { + x_212 = lean_alloc_ctor(1, 2, 0); +} else { + x_212 = x_211; +} +lean_ctor_set(x_212, 0, x_209); +lean_ctor_set(x_212, 1, x_210); +if (lean_is_scalar(x_208)) { + x_213 = lean_alloc_ctor(0, 2, 0); +} else { + x_213 = x_208; +} +lean_ctor_set(x_213, 0, x_212); +lean_ctor_set(x_213, 1, x_207); +x_214 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_214, 0, x_213); +lean_ctor_set(x_214, 1, x_206); +return x_214; +} +} +} +else +{ +uint8_t x_215; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_215 = !lean_is_exclusive(x_27); +if (x_215 == 0) +{ +return x_27; +} +else +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; +x_216 = lean_ctor_get(x_27, 0); +x_217 = lean_ctor_get(x_27, 1); +lean_inc(x_217); +lean_inc(x_216); +lean_dec(x_27); +x_218 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_218, 0, x_216); +lean_ctor_set(x_218, 1, x_217); +return x_218; +} +} +} +else +{ +uint8_t x_219; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_219 = !lean_is_exclusive(x_15); +if (x_219 == 0) +{ +lean_object* x_220; uint8_t x_221; +x_220 = lean_ctor_get(x_15, 0); +lean_dec(x_220); +x_221 = !lean_is_exclusive(x_16); +if (x_221 == 0) +{ +lean_object* x_222; uint8_t x_223; +x_222 = lean_ctor_get(x_16, 0); +lean_dec(x_222); +x_223 = !lean_is_exclusive(x_17); +if (x_223 == 0) +{ +return x_15; +} +else +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_224 = lean_ctor_get(x_17, 0); +x_225 = lean_ctor_get(x_17, 1); +lean_inc(x_225); +lean_inc(x_224); +lean_dec(x_17); +x_226 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_226, 0, x_224); +lean_ctor_set(x_226, 1, x_225); +lean_ctor_set(x_16, 0, x_226); +return x_15; +} +} +else +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +x_227 = lean_ctor_get(x_16, 1); +lean_inc(x_227); +lean_dec(x_16); +x_228 = lean_ctor_get(x_17, 0); +lean_inc(x_228); +x_229 = lean_ctor_get(x_17, 1); +lean_inc(x_229); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_230 = x_17; +} else { + lean_dec_ref(x_17); + x_230 = lean_box(0); +} +if (lean_is_scalar(x_230)) { + x_231 = lean_alloc_ctor(1, 2, 0); +} else { + x_231 = x_230; +} +lean_ctor_set(x_231, 0, x_228); +lean_ctor_set(x_231, 1, x_229); +x_232 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_227); +lean_ctor_set(x_15, 0, x_232); +return x_15; +} +} +else +{ +lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; +x_233 = lean_ctor_get(x_15, 1); +lean_inc(x_233); +lean_dec(x_15); +x_234 = lean_ctor_get(x_16, 1); +lean_inc(x_234); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_235 = x_16; +} else { + lean_dec_ref(x_16); + x_235 = lean_box(0); +} +x_236 = lean_ctor_get(x_17, 0); +lean_inc(x_236); +x_237 = lean_ctor_get(x_17, 1); +lean_inc(x_237); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_238 = x_17; +} else { + lean_dec_ref(x_17); + x_238 = lean_box(0); +} +if (lean_is_scalar(x_238)) { + x_239 = lean_alloc_ctor(1, 2, 0); +} else { + x_239 = x_238; +} +lean_ctor_set(x_239, 0, x_236); +lean_ctor_set(x_239, 1, x_237); +if (lean_is_scalar(x_235)) { + x_240 = lean_alloc_ctor(0, 2, 0); +} else { + x_240 = x_235; +} +lean_ctor_set(x_240, 0, x_239); +lean_ctor_set(x_240, 1, x_234); +x_241 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_241, 0, x_240); +lean_ctor_set(x_241, 1, x_233); +return x_241; +} +} +} +else +{ +uint8_t x_242; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_242 = !lean_is_exclusive(x_15); +if (x_242 == 0) +{ +return x_15; +} +else +{ +lean_object* x_243; lean_object* x_244; lean_object* x_245; +x_243 = lean_ctor_get(x_15, 0); +x_244 = lean_ctor_get(x_15, 1); +lean_inc(x_244); +lean_inc(x_243); +lean_dec(x_15); +x_245 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_245, 0, x_243); +lean_ctor_set(x_245, 1, x_244); +return x_245; +} +} +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("lean", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("transImports", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_recBuildExe___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanExe_recBuildExe___closed__2; +x_2 = l_Lake_LeanExe_recBuildExe___closed__3; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExe_recBuildExe(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_9, 1); +lean_inc(x_10); +x_11 = 1; +x_12 = l_Lean_Name_toString(x_10, x_11); +x_13 = l_Lake_LeanExe_recBuildExe___closed__1; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = lean_string_append(x_14, x_13); +lean_inc(x_9); +x_16 = l_Lake_LeanExeConfig_toLeanLibConfig(x_9); +lean_inc(x_8); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_8); +lean_ctor_set(x_17, 1, x_16); +x_18 = lean_ctor_get(x_9, 3); +lean_inc(x_18); +x_19 = lean_ctor_get(x_8, 2); +lean_inc(x_19); +x_20 = lean_ctor_get(x_19, 2); +lean_inc(x_20); +lean_inc(x_18); +x_21 = l_Lean_Name_append(x_20, x_18); +x_22 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_22, 0, x_17); +lean_ctor_set(x_22, 1, x_18); +lean_ctor_set(x_22, 2, x_21); +x_23 = l_Lake_LeanExe_recBuildExe___closed__4; +lean_inc(x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +x_25 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_25, 0, x_24); +lean_closure_set(x_25, 1, lean_box(0)); +x_26 = lean_alloc_closure((void*)(l_Lake_LeanExe_recBuildExe___lambda__1___boxed), 12, 5); +lean_closure_set(x_26, 0, x_22); +lean_closure_set(x_26, 1, x_9); +lean_closure_set(x_26, 2, x_8); +lean_closure_set(x_26, 3, x_19); +lean_closure_set(x_26, 4, x_1); +x_27 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg), 8, 2); +lean_closure_set(x_27, 0, x_25); +lean_closure_set(x_27, 1, x_26); +x_28 = l_Lake_withRegisterJob___rarg(x_15, x_27, x_2, x_3, x_4, x_5, x_6, x_7); +return x_28; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__1(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__2(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +lean_dec(x_1); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanExe_recBuildExe___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_fold___at_Lake_LeanExe_recBuildExe___spec__3(x_1, x_2, x_3); +lean_dec(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__4(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; size_t x_14; lean_object* x_15; +x_12 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_13 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_14 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_15 = l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5(x_12, x_2, x_13, x_14, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExe_recBuildExe___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +lean_object* x_13; +x_13 = l_Lake_LeanExe_recBuildExe___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12); +lean_dec(x_6); +return x_13; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Common(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Executable(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Common(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_LeanExe_recBuildExe___spec__5___closed__1); +l_Lake_LeanExe_recBuildExe___lambda__1___closed__1 = _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___lambda__1___closed__1); +l_Lake_LeanExe_recBuildExe___lambda__1___closed__2 = _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___lambda__1___closed__2); +l_Lake_LeanExe_recBuildExe___lambda__1___closed__3 = _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__3(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___lambda__1___closed__3); +l_Lake_LeanExe_recBuildExe___lambda__1___closed__4 = _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__4(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___lambda__1___closed__4); +l_Lake_LeanExe_recBuildExe___lambda__1___closed__5 = _init_l_Lake_LeanExe_recBuildExe___lambda__1___closed__5(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___lambda__1___closed__5); +l_Lake_LeanExe_recBuildExe___closed__1 = _init_l_Lake_LeanExe_recBuildExe___closed__1(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___closed__1); +l_Lake_LeanExe_recBuildExe___closed__2 = _init_l_Lake_LeanExe_recBuildExe___closed__2(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___closed__2); +l_Lake_LeanExe_recBuildExe___closed__3 = _init_l_Lake_LeanExe_recBuildExe___closed__3(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___closed__3); +l_Lake_LeanExe_recBuildExe___closed__4 = _init_l_Lake_LeanExe_recBuildExe___closed__4(); +lean_mark_persistent(l_Lake_LeanExe_recBuildExe___closed__4); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Facets.c b/stage0/stdlib/Lake/Build/Facets.c new file mode 100644 index 0000000000..4b5c540d90 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Facets.c @@ -0,0 +1,1187 @@ +// Lean compiler output +// Module: Lake.Build.Facets +// Imports: Init Lake.Build.Job Lake.Build.Data +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_Module_cFacet___closed__2; +static lean_object* l_Lake_Module_coNoExportFacet___closed__2; +lean_object* l_Lean_Name_reprPrec(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_coExportFacet; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__9; +static lean_object* l_Lake_Module_ileanFacet___closed__2; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__2; +LEAN_EXPORT lean_object* l_Lake_instCoeDepNameModuleFacetOfFamilyOutModuleData___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instReprModuleFacet___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_staticFacet___closed__2; +static lean_object* l_Lake_ExternLib_dynlibFacet___closed__2; +static lean_object* l_Lake_Module_oFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_ExternLib_sharedFacet; +LEAN_EXPORT lean_object* l_Lake_Module_cFacet; +static lean_object* l_Lake_ExternLib_staticFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_ExternLib_dynlibFacet; +static lean_object* l_Lake_Package_extraDepFacet___closed__1; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__13; +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_ileanFacet; +static lean_object* l_Lake_Module_leanArtsFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_depsFacet; +LEAN_EXPORT lean_object* l_Lake_LeanLib_extraDepFacet; +static lean_object* l_Lake_Module_bcFacet___closed__2; +LEAN_EXPORT lean_object* l_Lake_Dynlib_dir_x3f(lean_object*); +static lean_object* l_Lake_Module_ileanFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_coNoExportFacet; +static lean_object* l_Lake_instReprModuleFacet___closed__1; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__5; +lean_object* l_Lean_Name_mkStr3(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__11; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__17; +LEAN_EXPORT lean_object* l_Lake_LeanExe_exeFacet; +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_Module_bcoFacet___closed__1; +static lean_object* l_Lake_Module_oleanFacet___closed__2; +static lean_object* l_Lake_LeanLib_staticFacet___closed__1; +static lean_object* l_Lake_LeanLib_sharedFacet___closed__2; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__19; +lean_object* lean_nat_to_int(lean_object*); +static lean_object* l_Lake_LeanLib_sharedFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_leanArtsFacet; +LEAN_EXPORT lean_object* l_Lake_Module_leanArtsFacet; +static lean_object* l_Lake_Package_releaseFacet___closed__2; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__16; +static lean_object* l_Lake_Module_coExportFacet___closed__2; +static lean_object* l_Lake_Module_oleanFacet___closed__1; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__14; +LEAN_EXPORT lean_object* l_Lake_Module_bcFacet; +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg(lean_object*, lean_object*); +lean_object* l_System_FilePath_parent(lean_object*); +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__18; +static lean_object* l_Lake_Module_oExportFacet___closed__1; +static lean_object* l_Lake_LeanLib_staticExportFacet___closed__1; +static lean_object* l_Lake_LeanLib_staticFacet___closed__2; +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeDepNameModuleFacetOfFamilyOutModuleData(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_sharedFacet___closed__1; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__12; +static lean_object* l_Lake_LeanExe_exeFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticFacet; +static lean_object* l_Lake_Module_coFacet___closed__2; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__15; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__10; +static lean_object* l_Lake_Module_depsFacet___closed__2; +static lean_object* l_Lake_Package_releaseFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticExportFacet; +LEAN_EXPORT lean_object* l_Lake_Package_extraDepFacet; +lean_object* lean_string_length(lean_object*); +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__3; +static lean_object* l_Lake_Module_coNoExportFacet___closed__1; +static lean_object* l_Lake_Module_leanArtsFacet___closed__2; +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65_(lean_object*, lean_object*); +static lean_object* l_Lake_Package_optReleaseFacet___closed__1; +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_dynlibFacet___closed__1; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__8; +LEAN_EXPORT lean_object* l_Lake_Module_coFacet; +static lean_object* l_Lake_Module_cFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_bcoFacet; +LEAN_EXPORT lean_object* l_Lake_Module_oExportFacet; +static lean_object* l_Lake_Package_optReleaseFacet___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacet; +LEAN_EXPORT lean_object* l_Lake_instReprModuleFacet(lean_object*, lean_object*); +static lean_object* l_Lake_Module_coFacet___closed__1; +static lean_object* l_Lake_Package_extraDepFacet___closed__2; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__6; +LEAN_EXPORT lean_object* l_Lake_ExternLib_staticFacet; +LEAN_EXPORT lean_object* l_Lake_Module_oNoExportFacet; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__4; +static lean_object* l_Lake_Module_depsFacet___closed__1; +static lean_object* l_Lake_Module_coExportFacet___closed__1; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_sharedFacet; +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacet; +static lean_object* l_Lake_Module_oNoExportFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_oFacet; +static lean_object* l_Lake_LeanExe_exeFacet___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_optReleaseFacet; +static lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__7; +static lean_object* l_Lake_Module_bcFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_Dynlib_dir_x3f(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +lean_dec(x_1); +x_3 = l_System_FilePath_parent(x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("name", 4); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__1; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__2; +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" := ", 4); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__4; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__3; +x_2 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__5; +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(8u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(",", 1); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__8; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("data_eq", 7); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__10; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__12() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("_", 1); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__12; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__14() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("{ ", 2); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__15() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__14; +x_2 = lean_string_length(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__16() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__15; +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__14; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__18() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" }", 2); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__19() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__18; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_3 = lean_unsigned_to_nat(0u); +x_4 = l_Lean_Name_reprPrec(x_1, x_3); +x_5 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__7; +x_6 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +x_7 = 0; +x_8 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_8, 0, x_6); +lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_7); +x_9 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__6; +x_10 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_8); +x_11 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__9; +x_12 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set(x_12, 1, x_11); +x_13 = lean_box(1); +x_14 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_13); +x_15 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__11; +x_16 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_16, 0, x_14); +lean_ctor_set(x_16, 1, x_15); +x_17 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__5; +x_18 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set(x_18, 1, x_17); +x_19 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__13; +x_20 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +x_21 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__17; +x_22 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +x_23 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__19; +x_24 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +x_25 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__16; +x_26 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_24); +x_27 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set_uint8(x_27, sizeof(void*)*1, x_7); +return x_27; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65_(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___boxed), 2, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65_(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instReprModuleFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___boxed), 2, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instReprModuleFacet(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_instReprModuleFacet___closed__1; +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instReprModuleFacet___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_instReprModuleFacet(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeDepNameModuleFacetOfFamilyOutModuleData(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeDepNameModuleFacetOfFamilyOutModuleData___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_instCoeDepNameModuleFacetOfFamilyOutModuleData(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +static lean_object* _init_l_Lake_Module_depsFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("deps", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_depsFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_depsFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_depsFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_depsFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanArts", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_leanArtsFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_leanArtsFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oleanFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("olean", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oleanFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_oleanFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oleanFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oleanFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_ileanFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("ilean", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_ileanFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_ileanFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_ileanFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_ileanFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_cFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("c", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_cFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_cFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_cFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_cFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_bcFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("bc", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_bcFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_bcFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bcFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_bcFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("o", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_cFacet___closed__1; +x_2 = l_Lake_Module_coFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_coFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_coFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coExportFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("export", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coExportFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Module_cFacet___closed__1; +x_2 = l_Lake_Module_coFacet___closed__1; +x_3 = l_Lake_Module_coExportFacet___closed__1; +x_4 = l_Lean_Name_mkStr3(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_Module_coExportFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_coExportFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("noexport", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Module_cFacet___closed__1; +x_2 = l_Lake_Module_coFacet___closed__1; +x_3 = l_Lake_Module_coNoExportFacet___closed__1; +x_4 = l_Lean_Name_mkStr3(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_coNoExportFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_bcoFacet___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_bcFacet___closed__1; +x_2 = l_Lake_Module_coFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bcoFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_bcoFacet___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oFacet___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_coFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oFacet___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oExportFacet___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_coFacet___closed__1; +x_2 = l_Lake_Module_coExportFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oExportFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oExportFacet___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacet___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_coFacet___closed__1; +x_2 = l_Lake_Module_coNoExportFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oNoExportFacet___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("optRelease", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_optReleaseFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_optReleaseFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Package_releaseFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("release", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_releaseFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_releaseFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_releaseFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_releaseFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Package_extraDepFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("extraDep", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_extraDepFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_extraDepFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_extraDepFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_extraDepFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_leanArtsFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_leanArtsFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("static", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_staticFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_staticFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_staticExportFacet___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_staticFacet___closed__1; +x_2 = l_Lake_Module_coExportFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_staticExportFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_staticExportFacet___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("shared", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_sharedFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_sharedFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_extraDepFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_extraDepFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_exeFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanExe", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_exeFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanExe_exeFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanExe_exeFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanExe_exeFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_staticFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("externLib", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_staticFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_ExternLib_staticFacet___closed__1; +x_2 = l_Lake_LeanLib_staticFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_ExternLib_staticFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_ExternLib_staticFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_sharedFacet___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_ExternLib_staticFacet___closed__1; +x_2 = l_Lake_LeanLib_sharedFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_ExternLib_sharedFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_ExternLib_sharedFacet___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_dynlibFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("dynlib", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_dynlibFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_ExternLib_staticFacet___closed__1; +x_2 = l_Lake_ExternLib_dynlibFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_ExternLib_dynlibFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_ExternLib_dynlibFacet___closed__2; +return x_1; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Job(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Data(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Facets(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Job(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Data(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__1 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__1(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__1); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__2 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__2(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__2); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__3 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__3(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__3); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__4 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__4(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__4); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__5 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__5(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__5); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__6 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__6(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__6); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__7 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__7(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__7); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__8 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__8(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__8); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__9 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__9(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__9); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__10 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__10(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__10); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__11 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__11(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__11); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__12 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__12(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__12); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__13 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__13(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__13); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__14 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__14(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__14); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__15 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__15(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__15); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__16 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__16(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__16); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__17 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__17(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__17); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__18 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__18(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__18); +l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__19 = _init_l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__19(); +lean_mark_persistent(l___private_Lake_Build_Facets_0__Lake_reprModuleFacet____x40_Lake_Build_Facets___hyg_65____rarg___closed__19); +l_Lake_instReprModuleFacet___closed__1 = _init_l_Lake_instReprModuleFacet___closed__1(); +lean_mark_persistent(l_Lake_instReprModuleFacet___closed__1); +l_Lake_Module_depsFacet___closed__1 = _init_l_Lake_Module_depsFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_depsFacet___closed__1); +l_Lake_Module_depsFacet___closed__2 = _init_l_Lake_Module_depsFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_depsFacet___closed__2); +l_Lake_Module_depsFacet = _init_l_Lake_Module_depsFacet(); +lean_mark_persistent(l_Lake_Module_depsFacet); +l_Lake_Module_leanArtsFacet___closed__1 = _init_l_Lake_Module_leanArtsFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_leanArtsFacet___closed__1); +l_Lake_Module_leanArtsFacet___closed__2 = _init_l_Lake_Module_leanArtsFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_leanArtsFacet___closed__2); +l_Lake_Module_leanArtsFacet = _init_l_Lake_Module_leanArtsFacet(); +lean_mark_persistent(l_Lake_Module_leanArtsFacet); +l_Lake_Module_oleanFacet___closed__1 = _init_l_Lake_Module_oleanFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_oleanFacet___closed__1); +l_Lake_Module_oleanFacet___closed__2 = _init_l_Lake_Module_oleanFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_oleanFacet___closed__2); +l_Lake_Module_oleanFacet = _init_l_Lake_Module_oleanFacet(); +lean_mark_persistent(l_Lake_Module_oleanFacet); +l_Lake_Module_ileanFacet___closed__1 = _init_l_Lake_Module_ileanFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_ileanFacet___closed__1); +l_Lake_Module_ileanFacet___closed__2 = _init_l_Lake_Module_ileanFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_ileanFacet___closed__2); +l_Lake_Module_ileanFacet = _init_l_Lake_Module_ileanFacet(); +lean_mark_persistent(l_Lake_Module_ileanFacet); +l_Lake_Module_cFacet___closed__1 = _init_l_Lake_Module_cFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_cFacet___closed__1); +l_Lake_Module_cFacet___closed__2 = _init_l_Lake_Module_cFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_cFacet___closed__2); +l_Lake_Module_cFacet = _init_l_Lake_Module_cFacet(); +lean_mark_persistent(l_Lake_Module_cFacet); +l_Lake_Module_bcFacet___closed__1 = _init_l_Lake_Module_bcFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_bcFacet___closed__1); +l_Lake_Module_bcFacet___closed__2 = _init_l_Lake_Module_bcFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_bcFacet___closed__2); +l_Lake_Module_bcFacet = _init_l_Lake_Module_bcFacet(); +lean_mark_persistent(l_Lake_Module_bcFacet); +l_Lake_Module_coFacet___closed__1 = _init_l_Lake_Module_coFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_coFacet___closed__1); +l_Lake_Module_coFacet___closed__2 = _init_l_Lake_Module_coFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_coFacet___closed__2); +l_Lake_Module_coFacet = _init_l_Lake_Module_coFacet(); +lean_mark_persistent(l_Lake_Module_coFacet); +l_Lake_Module_coExportFacet___closed__1 = _init_l_Lake_Module_coExportFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_coExportFacet___closed__1); +l_Lake_Module_coExportFacet___closed__2 = _init_l_Lake_Module_coExportFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_coExportFacet___closed__2); +l_Lake_Module_coExportFacet = _init_l_Lake_Module_coExportFacet(); +lean_mark_persistent(l_Lake_Module_coExportFacet); +l_Lake_Module_coNoExportFacet___closed__1 = _init_l_Lake_Module_coNoExportFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_coNoExportFacet___closed__1); +l_Lake_Module_coNoExportFacet___closed__2 = _init_l_Lake_Module_coNoExportFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_coNoExportFacet___closed__2); +l_Lake_Module_coNoExportFacet = _init_l_Lake_Module_coNoExportFacet(); +lean_mark_persistent(l_Lake_Module_coNoExportFacet); +l_Lake_Module_bcoFacet___closed__1 = _init_l_Lake_Module_bcoFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_bcoFacet___closed__1); +l_Lake_Module_bcoFacet = _init_l_Lake_Module_bcoFacet(); +lean_mark_persistent(l_Lake_Module_bcoFacet); +l_Lake_Module_oFacet___closed__1 = _init_l_Lake_Module_oFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_oFacet___closed__1); +l_Lake_Module_oFacet = _init_l_Lake_Module_oFacet(); +lean_mark_persistent(l_Lake_Module_oFacet); +l_Lake_Module_oExportFacet___closed__1 = _init_l_Lake_Module_oExportFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_oExportFacet___closed__1); +l_Lake_Module_oExportFacet = _init_l_Lake_Module_oExportFacet(); +lean_mark_persistent(l_Lake_Module_oExportFacet); +l_Lake_Module_oNoExportFacet___closed__1 = _init_l_Lake_Module_oNoExportFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_oNoExportFacet___closed__1); +l_Lake_Module_oNoExportFacet = _init_l_Lake_Module_oNoExportFacet(); +lean_mark_persistent(l_Lake_Module_oNoExportFacet); +l_Lake_Package_optReleaseFacet___closed__1 = _init_l_Lake_Package_optReleaseFacet___closed__1(); +lean_mark_persistent(l_Lake_Package_optReleaseFacet___closed__1); +l_Lake_Package_optReleaseFacet___closed__2 = _init_l_Lake_Package_optReleaseFacet___closed__2(); +lean_mark_persistent(l_Lake_Package_optReleaseFacet___closed__2); +l_Lake_Package_optReleaseFacet = _init_l_Lake_Package_optReleaseFacet(); +lean_mark_persistent(l_Lake_Package_optReleaseFacet); +l_Lake_Package_releaseFacet___closed__1 = _init_l_Lake_Package_releaseFacet___closed__1(); +lean_mark_persistent(l_Lake_Package_releaseFacet___closed__1); +l_Lake_Package_releaseFacet___closed__2 = _init_l_Lake_Package_releaseFacet___closed__2(); +lean_mark_persistent(l_Lake_Package_releaseFacet___closed__2); +l_Lake_Package_releaseFacet = _init_l_Lake_Package_releaseFacet(); +lean_mark_persistent(l_Lake_Package_releaseFacet); +l_Lake_Package_extraDepFacet___closed__1 = _init_l_Lake_Package_extraDepFacet___closed__1(); +lean_mark_persistent(l_Lake_Package_extraDepFacet___closed__1); +l_Lake_Package_extraDepFacet___closed__2 = _init_l_Lake_Package_extraDepFacet___closed__2(); +lean_mark_persistent(l_Lake_Package_extraDepFacet___closed__2); +l_Lake_Package_extraDepFacet = _init_l_Lake_Package_extraDepFacet(); +lean_mark_persistent(l_Lake_Package_extraDepFacet); +l_Lake_LeanLib_leanArtsFacet = _init_l_Lake_LeanLib_leanArtsFacet(); +lean_mark_persistent(l_Lake_LeanLib_leanArtsFacet); +l_Lake_LeanLib_staticFacet___closed__1 = _init_l_Lake_LeanLib_staticFacet___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_staticFacet___closed__1); +l_Lake_LeanLib_staticFacet___closed__2 = _init_l_Lake_LeanLib_staticFacet___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_staticFacet___closed__2); +l_Lake_LeanLib_staticFacet = _init_l_Lake_LeanLib_staticFacet(); +lean_mark_persistent(l_Lake_LeanLib_staticFacet); +l_Lake_LeanLib_staticExportFacet___closed__1 = _init_l_Lake_LeanLib_staticExportFacet___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_staticExportFacet___closed__1); +l_Lake_LeanLib_staticExportFacet = _init_l_Lake_LeanLib_staticExportFacet(); +lean_mark_persistent(l_Lake_LeanLib_staticExportFacet); +l_Lake_LeanLib_sharedFacet___closed__1 = _init_l_Lake_LeanLib_sharedFacet___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacet___closed__1); +l_Lake_LeanLib_sharedFacet___closed__2 = _init_l_Lake_LeanLib_sharedFacet___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacet___closed__2); +l_Lake_LeanLib_sharedFacet = _init_l_Lake_LeanLib_sharedFacet(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacet); +l_Lake_LeanLib_extraDepFacet = _init_l_Lake_LeanLib_extraDepFacet(); +lean_mark_persistent(l_Lake_LeanLib_extraDepFacet); +l_Lake_LeanExe_exeFacet___closed__1 = _init_l_Lake_LeanExe_exeFacet___closed__1(); +lean_mark_persistent(l_Lake_LeanExe_exeFacet___closed__1); +l_Lake_LeanExe_exeFacet___closed__2 = _init_l_Lake_LeanExe_exeFacet___closed__2(); +lean_mark_persistent(l_Lake_LeanExe_exeFacet___closed__2); +l_Lake_LeanExe_exeFacet = _init_l_Lake_LeanExe_exeFacet(); +lean_mark_persistent(l_Lake_LeanExe_exeFacet); +l_Lake_ExternLib_staticFacet___closed__1 = _init_l_Lake_ExternLib_staticFacet___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_staticFacet___closed__1); +l_Lake_ExternLib_staticFacet___closed__2 = _init_l_Lake_ExternLib_staticFacet___closed__2(); +lean_mark_persistent(l_Lake_ExternLib_staticFacet___closed__2); +l_Lake_ExternLib_staticFacet = _init_l_Lake_ExternLib_staticFacet(); +lean_mark_persistent(l_Lake_ExternLib_staticFacet); +l_Lake_ExternLib_sharedFacet___closed__1 = _init_l_Lake_ExternLib_sharedFacet___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_sharedFacet___closed__1); +l_Lake_ExternLib_sharedFacet = _init_l_Lake_ExternLib_sharedFacet(); +lean_mark_persistent(l_Lake_ExternLib_sharedFacet); +l_Lake_ExternLib_dynlibFacet___closed__1 = _init_l_Lake_ExternLib_dynlibFacet___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_dynlibFacet___closed__1); +l_Lake_ExternLib_dynlibFacet___closed__2 = _init_l_Lake_ExternLib_dynlibFacet___closed__2(); +lean_mark_persistent(l_Lake_ExternLib_dynlibFacet___closed__2); +l_Lake_ExternLib_dynlibFacet = _init_l_Lake_ExternLib_dynlibFacet(); +lean_mark_persistent(l_Lake_ExternLib_dynlibFacet); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Fetch.c b/stage0/stdlib/Lake/Build/Fetch.c new file mode 100644 index 0000000000..a2472399de --- /dev/null +++ b/stage0/stdlib/Lake/Build/Fetch.c @@ -0,0 +1,6927 @@ +// Lean compiler output +// Module: Lake.Build.Fetch +// Imports: Init Lake.Util.Error Lake.Util.Cycle Lake.Util.EquipT Lake.Build.Info Lake.Build.Store +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__3; +LEAN_EXPORT lean_object* l_Lake_registerJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIORecBuildM(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__2(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_ensureJob___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_get_set_stdout(lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Job_renew___rarg(lean_object*); +static lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__2; +LEAN_EXPORT lean_object* l_Lake_registerJob(lean_object*); +static lean_object* l_Lake_buildCycleError___rarg___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_ensureJob(lean_object*); +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildCycleError___rarg___lambda__1___closed__2; +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run_x27___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_RecBuildM_runJobM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_string_validate_utf8(lean_object*); +lean_object* l_List_mapTR_loop___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__1; +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run_x27(lean_object*); +static lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__4; +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_String_isEmpty(lean_object*); +static lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__6; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_task_pure(lean_object*); +lean_object* lean_st_ref_take(lean_object*, lean_object*); +extern lean_object* l_ByteArray_empty; +LEAN_EXPORT lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_maybeRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_withRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_ensureJob___rarg___closed__1; +lean_object* lean_st_ref_get(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIORecBuildM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_maybeRegisterJob(lean_object*); +lean_object* lean_st_mk_ref(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftJobMRecBuildM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_panic___at_String_fromUTF8_x21___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__5(lean_object*); +lean_object* l_Lake_BuildKey_toString(lean_object*); +static lean_object* l_Lake_buildCycleError___rarg___closed__2; +extern lean_object* l_Task_Priority_default; +LEAN_EXPORT lean_object* l_Lake_RecBuildM_runJobM(lean_object*); +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg___lambda__1(lean_object*, lean_object*); +lean_object* l_IO_FS_Stream_ofBuffer(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_instMonadBaseIO; +lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_ensureJob___spec__4(lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__1; +lean_object* lean_get_set_stderr(lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__4; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_from_utf8(lean_object*); +LEAN_EXPORT lean_object* l_List_mapTR_loop___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__2(lean_object*, lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_buildCycleError___rarg___closed__1; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__6(lean_object*); +lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftJobMRecBuildM(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__3(lean_object*); +lean_object* l_StateT_instMonad___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_RecBuildM_runJobM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIORecBuildM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_withRegisterJob(lean_object*); +uint8_t lean_nat_dec_eq(lean_object*, lean_object*); +static lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__5; +LEAN_EXPORT lean_object* l_Lake_registerJob___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_shrink___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___rarg(lean_object*, lean_object*); +lean_object* lean_task_map(lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___rarg___lambda__1(lean_object*); +lean_object* lean_get_set_stdin(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_instMonadCallStackOfCallStackTOfMonad___rarg(lean_object*); +lean_object* l_List_reverse___rarg(lean_object*); +static lean_object* l_Lake_buildCycleError___rarg___closed__3; +lean_object* l_String_intercalate(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM; +lean_object* lean_string_append(lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +lean_object* l_Lake_EStateT_instMonad___rarg(lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__3; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__2; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftJobMRecBuildM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_maybeRegisterJob___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildInfo_fetch(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1(lean_object*); +lean_object* l_ReaderT_instMonad___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIORecBuildM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = lean_apply_2(x_1, x_4, x_6); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_7); +if (x_9 == 0) +{ +lean_object* x_10; uint8_t x_11; +x_10 = lean_ctor_get(x_7, 0); +lean_dec(x_10); +x_11 = !lean_is_exclusive(x_8); +if (x_11 == 0) +{ +lean_object* x_12; +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_8); +lean_ctor_set(x_12, 1, x_5); +lean_ctor_set(x_7, 0, x_12); +return x_7; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_8, 0); +x_14 = lean_ctor_get(x_8, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_8); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_5); +lean_ctor_set(x_7, 0, x_16); +return x_7; +} +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_7, 1); +lean_inc(x_17); +lean_dec(x_7); +x_18 = lean_ctor_get(x_8, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_8, 1); +lean_inc(x_19); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + lean_ctor_release(x_8, 1); + x_20 = x_8; +} else { + lean_dec_ref(x_8); + x_20 = lean_box(0); +} +if (lean_is_scalar(x_20)) { + x_21 = lean_alloc_ctor(0, 2, 0); +} else { + x_21 = x_20; +} +lean_ctor_set(x_21, 0, x_18); +lean_ctor_set(x_21, 1, x_19); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_5); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_17); +return x_23; +} +} +else +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_7); +if (x_24 == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_7, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_8); +if (x_26 == 0) +{ +lean_object* x_27; +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_8); +lean_ctor_set(x_27, 1, x_5); +lean_ctor_set(x_7, 0, x_27); +return x_7; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_28 = lean_ctor_get(x_8, 0); +x_29 = lean_ctor_get(x_8, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_8); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_5); +lean_ctor_set(x_7, 0, x_31); +return x_7; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_32 = lean_ctor_get(x_7, 1); +lean_inc(x_32); +lean_dec(x_7); +x_33 = lean_ctor_get(x_8, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_8, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + lean_ctor_release(x_8, 1); + x_35 = x_8; +} else { + lean_dec_ref(x_8); + x_35 = lean_box(0); +} +if (lean_is_scalar(x_35)) { + x_36 = lean_alloc_ctor(1, 2, 0); +} else { + x_36 = x_35; +} +lean_ctor_set(x_36, 0, x_33); +lean_ctor_set(x_36, 1, x_34); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_5); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_32); +return x_38; +} +} +} +else +{ +uint8_t x_39; +lean_dec(x_5); +x_39 = !lean_is_exclusive(x_7); +if (x_39 == 0) +{ +return x_7; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_7, 0); +x_41 = lean_ctor_get(x_7, 1); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_7); +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +return x_42; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIORecBuildM(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_instMonadLiftLogIORecBuildM___rarg___boxed), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIORecBuildM___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_instMonadLiftLogIORecBuildM___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_3); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_RecBuildM_runJobM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; lean_object* x_9; +x_7 = 0; +x_8 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_8, 0, x_4); +lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_7); +x_9 = lean_apply_3(x_1, x_3, x_8, x_6); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_9); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_9, 0); +lean_dec(x_12); +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_10, 1); +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +lean_dec(x_14); +lean_ctor_set(x_10, 1, x_15); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_10); +lean_ctor_set(x_16, 1, x_5); +lean_ctor_set(x_9, 0, x_16); +return x_9; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_17 = lean_ctor_get(x_10, 0); +x_18 = lean_ctor_get(x_10, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_10); +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +lean_dec(x_18); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_17); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_5); +lean_ctor_set(x_9, 0, x_21); +return x_9; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_22 = lean_ctor_get(x_9, 1); +lean_inc(x_22); +lean_dec(x_9); +x_23 = lean_ctor_get(x_10, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_10, 1); +lean_inc(x_24); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_25 = x_10; +} else { + lean_dec_ref(x_10); + x_25 = lean_box(0); +} +x_26 = lean_ctor_get(x_24, 0); +lean_inc(x_26); +lean_dec(x_24); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_23); +lean_ctor_set(x_27, 1, x_26); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_5); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_22); +return x_29; +} +} +else +{ +uint8_t x_30; +x_30 = !lean_is_exclusive(x_9); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_9, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_10); +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_10, 1); +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +lean_dec(x_33); +lean_ctor_set(x_10, 1, x_34); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_10); +lean_ctor_set(x_35, 1, x_5); +lean_ctor_set(x_9, 0, x_35); +return x_9; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_10, 0); +x_37 = lean_ctor_get(x_10, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_10); +x_38 = lean_ctor_get(x_37, 0); +lean_inc(x_38); +lean_dec(x_37); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_36); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_5); +lean_ctor_set(x_9, 0, x_40); +return x_9; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_41 = lean_ctor_get(x_9, 1); +lean_inc(x_41); +lean_dec(x_9); +x_42 = lean_ctor_get(x_10, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_10, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_44 = x_10; +} else { + lean_dec_ref(x_10); + x_44 = lean_box(0); +} +x_45 = lean_ctor_get(x_43, 0); +lean_inc(x_45); +lean_dec(x_43); +if (lean_is_scalar(x_44)) { + x_46 = lean_alloc_ctor(1, 2, 0); +} else { + x_46 = x_44; +} +lean_ctor_set(x_46, 0, x_42); +lean_ctor_set(x_46, 1, x_45); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_5); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_41); +return x_48; +} +} +} +else +{ +uint8_t x_49; +lean_dec(x_5); +x_49 = !lean_is_exclusive(x_9); +if (x_49 == 0) +{ +return x_9; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_9, 0); +x_51 = lean_ctor_get(x_9, 1); +lean_inc(x_51); +lean_inc(x_50); +lean_dec(x_9); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_50); +lean_ctor_set(x_52, 1, x_51); +return x_52; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_RecBuildM_runJobM(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_RecBuildM_runJobM___rarg___boxed), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_RecBuildM_runJobM___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_RecBuildM_runJobM___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftJobMRecBuildM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; lean_object* x_9; +x_7 = 0; +x_8 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_8, 0, x_4); +lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_7); +x_9 = lean_apply_3(x_1, x_3, x_8, x_6); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_9); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_9, 0); +lean_dec(x_12); +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_10, 1); +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +lean_dec(x_14); +lean_ctor_set(x_10, 1, x_15); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_10); +lean_ctor_set(x_16, 1, x_5); +lean_ctor_set(x_9, 0, x_16); +return x_9; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_17 = lean_ctor_get(x_10, 0); +x_18 = lean_ctor_get(x_10, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_10); +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +lean_dec(x_18); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_17); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_5); +lean_ctor_set(x_9, 0, x_21); +return x_9; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_22 = lean_ctor_get(x_9, 1); +lean_inc(x_22); +lean_dec(x_9); +x_23 = lean_ctor_get(x_10, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_10, 1); +lean_inc(x_24); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_25 = x_10; +} else { + lean_dec_ref(x_10); + x_25 = lean_box(0); +} +x_26 = lean_ctor_get(x_24, 0); +lean_inc(x_26); +lean_dec(x_24); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_23); +lean_ctor_set(x_27, 1, x_26); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_5); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_22); +return x_29; +} +} +else +{ +uint8_t x_30; +x_30 = !lean_is_exclusive(x_9); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_9, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_10); +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_10, 1); +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +lean_dec(x_33); +lean_ctor_set(x_10, 1, x_34); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_10); +lean_ctor_set(x_35, 1, x_5); +lean_ctor_set(x_9, 0, x_35); +return x_9; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_10, 0); +x_37 = lean_ctor_get(x_10, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_10); +x_38 = lean_ctor_get(x_37, 0); +lean_inc(x_38); +lean_dec(x_37); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_36); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_5); +lean_ctor_set(x_9, 0, x_40); +return x_9; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_41 = lean_ctor_get(x_9, 1); +lean_inc(x_41); +lean_dec(x_9); +x_42 = lean_ctor_get(x_10, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_10, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_44 = x_10; +} else { + lean_dec_ref(x_10); + x_44 = lean_box(0); +} +x_45 = lean_ctor_get(x_43, 0); +lean_inc(x_45); +lean_dec(x_43); +if (lean_is_scalar(x_44)) { + x_46 = lean_alloc_ctor(1, 2, 0); +} else { + x_46 = x_44; +} +lean_ctor_set(x_46, 0, x_42); +lean_ctor_set(x_46, 1, x_45); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_5); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_41); +return x_48; +} +} +} +else +{ +uint8_t x_49; +lean_dec(x_5); +x_49 = !lean_is_exclusive(x_9); +if (x_49 == 0) +{ +return x_9; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_9, 0); +x_51 = lean_ctor_get(x_9, 1); +lean_inc(x_51); +lean_inc(x_50); +lean_dec(x_9); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_50); +lean_ctor_set(x_52, 1, x_51); +return x_52; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftJobMRecBuildM(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_instMonadLiftJobMRecBuildM___rarg___boxed), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftJobMRecBuildM___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_instMonadLiftJobMRecBuildM___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = lean_apply_5(x_3, x_1, x_4, x_5, x_2, x_6); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +if (lean_obj_tag(x_9) == 0) +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_7); +if (x_10 == 0) +{ +lean_object* x_11; uint8_t x_12; +x_11 = lean_ctor_get(x_7, 0); +lean_dec(x_11); +x_12 = !lean_is_exclusive(x_8); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_8, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_9); +if (x_14 == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_9, 0); +lean_ctor_set(x_8, 0, x_15); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_7, 0, x_9); +return x_7; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_9, 0); +x_17 = lean_ctor_get(x_9, 1); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_9); +lean_ctor_set(x_8, 0, x_16); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_8); +lean_ctor_set(x_18, 1, x_17); +lean_ctor_set(x_7, 0, x_18); +return x_7; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_19 = lean_ctor_get(x_8, 1); +lean_inc(x_19); +lean_dec(x_8); +x_20 = lean_ctor_get(x_9, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_9, 1); +lean_inc(x_21); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_22 = x_9; +} else { + lean_dec_ref(x_9); + x_22 = lean_box(0); +} +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_20); +lean_ctor_set(x_23, 1, x_19); +if (lean_is_scalar(x_22)) { + x_24 = lean_alloc_ctor(0, 2, 0); +} else { + x_24 = x_22; +} +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_21); +lean_ctor_set(x_7, 0, x_24); +return x_7; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_25 = lean_ctor_get(x_7, 1); +lean_inc(x_25); +lean_dec(x_7); +x_26 = lean_ctor_get(x_8, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + lean_ctor_release(x_8, 1); + x_27 = x_8; +} else { + lean_dec_ref(x_8); + x_27 = lean_box(0); +} +x_28 = lean_ctor_get(x_9, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_9, 1); +lean_inc(x_29); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_30 = x_9; +} else { + lean_dec_ref(x_9); + x_30 = lean_box(0); +} +if (lean_is_scalar(x_27)) { + x_31 = lean_alloc_ctor(0, 2, 0); +} else { + x_31 = x_27; +} +lean_ctor_set(x_31, 0, x_28); +lean_ctor_set(x_31, 1, x_26); +if (lean_is_scalar(x_30)) { + x_32 = lean_alloc_ctor(0, 2, 0); +} else { + x_32 = x_30; +} +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_29); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_25); +return x_33; +} +} +else +{ +uint8_t x_34; +lean_dec(x_8); +x_34 = !lean_is_exclusive(x_7); +if (x_34 == 0) +{ +lean_object* x_35; uint8_t x_36; +x_35 = lean_ctor_get(x_7, 0); +lean_dec(x_35); +x_36 = !lean_is_exclusive(x_9); +if (x_36 == 0) +{ +lean_ctor_set(x_7, 0, x_9); +return x_7; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_9, 0); +x_38 = lean_ctor_get(x_9, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_9); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +lean_ctor_set(x_7, 0, x_39); +return x_7; +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_40 = lean_ctor_get(x_7, 1); +lean_inc(x_40); +lean_dec(x_7); +x_41 = lean_ctor_get(x_9, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_9, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_43 = x_9; +} else { + lean_dec_ref(x_9); + x_43 = lean_box(0); +} +if (lean_is_scalar(x_43)) { + x_44 = lean_alloc_ctor(1, 2, 0); +} else { + x_44 = x_43; +} +lean_ctor_set(x_44, 0, x_41); +lean_ctor_set(x_44, 1, x_42); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_40); +return x_45; +} +} +} +else +{ +uint8_t x_46; +x_46 = !lean_is_exclusive(x_7); +if (x_46 == 0) +{ +return x_7; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_7, 0); +x_48 = lean_ctor_get(x_7, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_7); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_RecBuildM_run___rarg), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run_x27___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_box(0); +x_6 = lean_box(0); +x_7 = lean_apply_5(x_1, x_5, x_2, x_3, x_6, x_4); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +lean_dec(x_8); +if (lean_obj_tag(x_9) == 0) +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_7); +if (x_10 == 0) +{ +lean_object* x_11; uint8_t x_12; +x_11 = lean_ctor_get(x_7, 0); +lean_dec(x_11); +x_12 = !lean_is_exclusive(x_9); +if (x_12 == 0) +{ +lean_ctor_set(x_7, 0, x_9); +return x_7; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = lean_ctor_get(x_9, 0); +x_14 = lean_ctor_get(x_9, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_9); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +lean_ctor_set(x_7, 0, x_15); +return x_7; +} +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_7, 1); +lean_inc(x_16); +lean_dec(x_7); +x_17 = lean_ctor_get(x_9, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_9, 1); +lean_inc(x_18); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_19 = x_9; +} else { + lean_dec_ref(x_9); + x_19 = lean_box(0); +} +if (lean_is_scalar(x_19)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_19; +} +lean_ctor_set(x_20, 0, x_17); +lean_ctor_set(x_20, 1, x_18); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_16); +return x_21; +} +} +else +{ +uint8_t x_22; +x_22 = !lean_is_exclusive(x_7); +if (x_22 == 0) +{ +lean_object* x_23; uint8_t x_24; +x_23 = lean_ctor_get(x_7, 0); +lean_dec(x_23); +x_24 = !lean_is_exclusive(x_9); +if (x_24 == 0) +{ +lean_ctor_set(x_7, 0, x_9); +return x_7; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_9, 0); +x_26 = lean_ctor_get(x_9, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_9); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +lean_ctor_set(x_7, 0, x_27); +return x_7; +} +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_7, 1); +lean_inc(x_28); +lean_dec(x_7); +x_29 = lean_ctor_get(x_9, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_9, 1); +lean_inc(x_30); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_31 = x_9; +} else { + lean_dec_ref(x_9); + x_31 = lean_box(0); +} +if (lean_is_scalar(x_31)) { + x_32 = lean_alloc_ctor(1, 2, 0); +} else { + x_32 = x_31; +} +lean_ctor_set(x_32, 0, x_29); +lean_ctor_set(x_32, 1, x_30); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_28); +return x_33; +} +} +} +else +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_7); +if (x_34 == 0) +{ +return x_7; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_7, 0); +x_36 = lean_ctor_get(x_7, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_7); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +return x_37; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_RecBuildM_run_x27(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_RecBuildM_run_x27___rarg), 4, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_buildCycleError___rarg___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" ", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_buildCycleError___rarg___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___rarg___lambda__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_2 = l_Lake_BuildKey_toString(x_1); +x_3 = l_Lake_buildCycleError___rarg___lambda__1___closed__1; +x_4 = lean_string_append(x_3, x_2); +lean_dec(x_2); +x_5 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_6 = lean_string_append(x_4, x_5); +return x_6; +} +} +static lean_object* _init_l_Lake_buildCycleError___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildCycleError___rarg___lambda__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_buildCycleError___rarg___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("\n", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_buildCycleError___rarg___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("build cycle detected:\n", 22); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_3 = lean_box(0); +x_4 = l_Lake_buildCycleError___rarg___closed__1; +x_5 = l_List_mapTR_loop___rarg(x_4, x_2, x_3); +x_6 = l_Lake_buildCycleError___rarg___closed__2; +x_7 = l_String_intercalate(x_6, x_5); +x_8 = l_Lake_buildCycleError___rarg___closed__3; +x_9 = lean_string_append(x_8, x_7); +lean_dec(x_7); +x_10 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_11 = lean_string_append(x_9, x_10); +x_12 = lean_apply_2(x_1, lean_box(0), x_11); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_buildCycleError___rarg), 2, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_List_mapTR_loop___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_3; +x_3 = l_List_reverse___rarg(x_2); +return x_3; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_1); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_5 = lean_ctor_get(x_1, 0); +x_6 = lean_ctor_get(x_1, 1); +x_7 = l_Lake_BuildKey_toString(x_5); +x_8 = l_Lake_buildCycleError___rarg___lambda__1___closed__1; +x_9 = lean_string_append(x_8, x_7); +lean_dec(x_7); +x_10 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_11 = lean_string_append(x_9, x_10); +lean_ctor_set(x_1, 1, x_2); +lean_ctor_set(x_1, 0, x_11); +{ +lean_object* _tmp_0 = x_6; +lean_object* _tmp_1 = x_1; +x_1 = _tmp_0; +x_2 = _tmp_1; +} +goto _start; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_13 = lean_ctor_get(x_1, 0); +x_14 = lean_ctor_get(x_1, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_1); +x_15 = l_Lake_BuildKey_toString(x_13); +x_16 = l_Lake_buildCycleError___rarg___lambda__1___closed__1; +x_17 = lean_string_append(x_16, x_15); +lean_dec(x_15); +x_18 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_19 = lean_string_append(x_17, x_18); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_2); +x_1 = x_14; +x_2 = x_20; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_7 = lean_box(0); +x_8 = l_List_mapTR_loop___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__2(x_1, x_7); +x_9 = l_Lake_buildCycleError___rarg___closed__2; +x_10 = l_String_intercalate(x_9, x_8); +x_11 = l_Lake_buildCycleError___rarg___closed__3; +x_12 = lean_string_append(x_11, x_10); +lean_dec(x_10); +x_13 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_14 = lean_string_append(x_12, x_13); +x_15 = 3; +x_16 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_16, 0, x_14); +lean_ctor_set_uint8(x_16, sizeof(void*)*1, x_15); +x_17 = lean_array_get_size(x_4); +x_18 = lean_array_push(x_4, x_16); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_5); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_6); +return x_21; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1___rarg___boxed), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1___rarg(x_2, x_3, x_4, x_5, x_6, x_7); +return x_8; +} +} +static lean_object* _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_instMonadBaseIO; +x_2 = l_StateT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__1; +x_2 = l_Lake_EStateT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__2; +x_2 = l_ReaderT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__3; +x_2 = l_Lake_instMonadCallStackOfCallStackTOfMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instMonadCycleOfBuildKeyRecBuildM___lambda__1___boxed), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__4; +x_2 = l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__5; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__6; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildCycleError___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__1___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_3); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadCycleOfBuildKeyRecBuildM___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_instMonadCycleOfBuildKeyRecBuildM___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_4); +lean_dec(x_3); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = lean_apply_6(x_3, x_1, x_4, x_5, x_6, x_7, x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildInfo_fetch(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdout(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_ensureJob___spec__2___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdin(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_ensureJob___spec__3___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_ensureJob___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stderr(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stderr(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stderr(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stderr(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stderr(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stderr(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stderr(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_ensureJob___spec__4(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_ensureJob___spec__4___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__5___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdout(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_ensureJob___spec__5(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_ensureJob___spec__5___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdin(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_ensureJob___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_ensureJob___spec__6___rarg), 8, 0); +return x_2; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_ByteArray_empty; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Init.Data.String.Extra", 22); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("String.fromUTF8!", 16); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid UTF-8 string", 20); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5() { +_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_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__2; +x_2 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__3; +x_3 = lean_unsigned_to_nat(92u); +x_4 = lean_unsigned_to_nat(47u); +x_5 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__4; +x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; +x_9 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__1; +x_10 = lean_st_mk_ref(x_9, x_8); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_st_mk_ref(x_9, x_12); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +lean_dec(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_11); +lean_inc(x_14); +x_17 = l_IO_FS_Stream_ofBuffer(x_14); +if (x_2 == 0) +{ +lean_object* x_18; lean_object* x_19; +x_18 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_ensureJob___spec__2___rarg), 8, 2); +lean_closure_set(x_18, 0, x_17); +lean_closure_set(x_18, 1, x_1); +x_19 = l_IO_withStdin___at_Lake_ensureJob___spec__3___rarg(x_16, x_18, x_3, x_4, x_5, x_6, x_7, x_15); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; uint8_t x_23; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = !lean_is_exclusive(x_20); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; uint8_t x_26; +x_24 = lean_ctor_get(x_20, 1); +x_25 = lean_ctor_get(x_20, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_21); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_21, 0); +x_28 = lean_ctor_get(x_21, 1); +x_29 = lean_st_ref_get(x_14, x_22); +lean_dec(x_14); +if (lean_obj_tag(x_29) == 0) +{ +uint8_t x_30; +x_30 = !lean_is_exclusive(x_29); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; uint8_t x_33; +x_31 = lean_ctor_get(x_29, 0); +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +lean_dec(x_31); +x_33 = lean_string_validate_utf8(x_32); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_32); +x_34 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_35 = l_panic___at_String_fromUTF8_x21___spec__1(x_34); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_35); +lean_ctor_set(x_21, 0, x_20); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_21); +lean_ctor_set(x_36, 1, x_24); +lean_ctor_set(x_29, 0, x_36); +return x_29; +} +else +{ +lean_object* x_37; lean_object* x_38; +x_37 = lean_string_from_utf8(x_32); +lean_dec(x_32); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_37); +lean_ctor_set(x_21, 0, x_20); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_21); +lean_ctor_set(x_38, 1, x_24); +lean_ctor_set(x_29, 0, x_38); +return x_29; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; +x_39 = lean_ctor_get(x_29, 0); +x_40 = lean_ctor_get(x_29, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_29); +x_41 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +lean_dec(x_39); +x_42 = lean_string_validate_utf8(x_41); +if (x_42 == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_dec(x_41); +x_43 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_44 = l_panic___at_String_fromUTF8_x21___spec__1(x_43); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_44); +lean_ctor_set(x_21, 0, x_20); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_21); +lean_ctor_set(x_45, 1, x_24); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_40); +return x_46; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_string_from_utf8(x_41); +lean_dec(x_41); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_47); +lean_ctor_set(x_21, 0, x_20); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_21); +lean_ctor_set(x_48, 1, x_24); +x_49 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_40); +return x_49; +} +} +} +else +{ +uint8_t x_50; +lean_free_object(x_21); +lean_dec(x_28); +lean_dec(x_27); +lean_free_object(x_20); +lean_dec(x_24); +x_50 = !lean_is_exclusive(x_29); +if (x_50 == 0) +{ +return x_29; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_29, 0); +x_52 = lean_ctor_get(x_29, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_29); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; +} +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_21, 0); +x_55 = lean_ctor_get(x_21, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_21); +x_56 = lean_st_ref_get(x_14, x_22); +lean_dec(x_14); +if (lean_obj_tag(x_56) == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; +x_57 = lean_ctor_get(x_56, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_56, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_56)) { + lean_ctor_release(x_56, 0); + lean_ctor_release(x_56, 1); + x_59 = x_56; +} else { + lean_dec_ref(x_56); + x_59 = lean_box(0); +} +x_60 = lean_ctor_get(x_57, 0); +lean_inc(x_60); +lean_dec(x_57); +x_61 = lean_string_validate_utf8(x_60); +if (x_61 == 0) +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +lean_dec(x_60); +x_62 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_63 = l_panic___at_String_fromUTF8_x21___spec__1(x_62); +lean_ctor_set(x_20, 1, x_54); +lean_ctor_set(x_20, 0, x_63); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_20); +lean_ctor_set(x_64, 1, x_55); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_24); +if (lean_is_scalar(x_59)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_59; +} +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_58); +return x_66; +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_67 = lean_string_from_utf8(x_60); +lean_dec(x_60); +lean_ctor_set(x_20, 1, x_54); +lean_ctor_set(x_20, 0, x_67); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_20); +lean_ctor_set(x_68, 1, x_55); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_24); +if (lean_is_scalar(x_59)) { + x_70 = lean_alloc_ctor(0, 2, 0); +} else { + x_70 = x_59; +} +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_58); +return x_70; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_55); +lean_dec(x_54); +lean_free_object(x_20); +lean_dec(x_24); +x_71 = lean_ctor_get(x_56, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_56, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_56)) { + lean_ctor_release(x_56, 0); + lean_ctor_release(x_56, 1); + x_73 = x_56; +} else { + lean_dec_ref(x_56); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); +lean_dec(x_20); +x_76 = lean_ctor_get(x_21, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_21, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_78 = x_21; +} else { + lean_dec_ref(x_21); + x_78 = lean_box(0); +} +x_79 = lean_st_ref_get(x_14, x_22); +lean_dec(x_14); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; uint8_t x_84; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_79, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_82 = x_79; +} else { + lean_dec_ref(x_79); + x_82 = lean_box(0); +} +x_83 = lean_ctor_get(x_80, 0); +lean_inc(x_83); +lean_dec(x_80); +x_84 = lean_string_validate_utf8(x_83); +if (x_84 == 0) +{ +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_dec(x_83); +x_85 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_86 = l_panic___at_String_fromUTF8_x21___spec__1(x_85); +x_87 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_76); +if (lean_is_scalar(x_78)) { + x_88 = lean_alloc_ctor(0, 2, 0); +} else { + x_88 = x_78; +} +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_77); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_75); +if (lean_is_scalar(x_82)) { + x_90 = lean_alloc_ctor(0, 2, 0); +} else { + x_90 = x_82; +} +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_81); +return x_90; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_91 = lean_string_from_utf8(x_83); +lean_dec(x_83); +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_76); +if (lean_is_scalar(x_78)) { + x_93 = lean_alloc_ctor(0, 2, 0); +} else { + x_93 = x_78; +} +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_77); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_75); +if (lean_is_scalar(x_82)) { + x_95 = lean_alloc_ctor(0, 2, 0); +} else { + x_95 = x_82; +} +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_81); +return x_95; +} +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; +lean_dec(x_78); +lean_dec(x_77); +lean_dec(x_76); +lean_dec(x_75); +x_96 = lean_ctor_get(x_79, 0); +lean_inc(x_96); +x_97 = lean_ctor_get(x_79, 1); +lean_inc(x_97); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_98 = x_79; +} else { + lean_dec_ref(x_79); + x_98 = lean_box(0); +} +if (lean_is_scalar(x_98)) { + x_99 = lean_alloc_ctor(1, 2, 0); +} else { + x_99 = x_98; +} +lean_ctor_set(x_99, 0, x_96); +lean_ctor_set(x_99, 1, x_97); +return x_99; +} +} +} +else +{ +uint8_t x_100; +lean_dec(x_14); +x_100 = !lean_is_exclusive(x_19); +if (x_100 == 0) +{ +lean_object* x_101; uint8_t x_102; +x_101 = lean_ctor_get(x_19, 0); +lean_dec(x_101); +x_102 = !lean_is_exclusive(x_20); +if (x_102 == 0) +{ +lean_object* x_103; uint8_t x_104; +x_103 = lean_ctor_get(x_20, 0); +lean_dec(x_103); +x_104 = !lean_is_exclusive(x_21); +if (x_104 == 0) +{ +return x_19; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_105 = lean_ctor_get(x_21, 0); +x_106 = lean_ctor_get(x_21, 1); +lean_inc(x_106); +lean_inc(x_105); +lean_dec(x_21); +x_107 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_107, 0, x_105); +lean_ctor_set(x_107, 1, x_106); +lean_ctor_set(x_20, 0, x_107); +return x_19; +} +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_108 = lean_ctor_get(x_20, 1); +lean_inc(x_108); +lean_dec(x_20); +x_109 = lean_ctor_get(x_21, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_21, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_111 = x_21; +} else { + lean_dec_ref(x_21); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_108); +lean_ctor_set(x_19, 0, x_113); +return x_19; +} +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; +x_114 = lean_ctor_get(x_19, 1); +lean_inc(x_114); +lean_dec(x_19); +x_115 = lean_ctor_get(x_20, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_116 = x_20; +} else { + lean_dec_ref(x_20); + x_116 = lean_box(0); +} +x_117 = lean_ctor_get(x_21, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_21, 1); +lean_inc(x_118); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_119 = x_21; +} else { + lean_dec_ref(x_21); + x_119 = lean_box(0); +} +if (lean_is_scalar(x_119)) { + x_120 = lean_alloc_ctor(1, 2, 0); +} else { + x_120 = x_119; +} +lean_ctor_set(x_120, 0, x_117); +lean_ctor_set(x_120, 1, x_118); +if (lean_is_scalar(x_116)) { + x_121 = lean_alloc_ctor(0, 2, 0); +} else { + x_121 = x_116; +} +lean_ctor_set(x_121, 0, x_120); +lean_ctor_set(x_121, 1, x_115); +x_122 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_122, 0, x_121); +lean_ctor_set(x_122, 1, x_114); +return x_122; +} +} +} +else +{ +uint8_t x_123; +lean_dec(x_14); +x_123 = !lean_is_exclusive(x_19); +if (x_123 == 0) +{ +return x_19; +} +else +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; +x_124 = lean_ctor_get(x_19, 0); +x_125 = lean_ctor_get(x_19, 1); +lean_inc(x_125); +lean_inc(x_124); +lean_dec(x_19); +x_126 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_126, 0, x_124); +lean_ctor_set(x_126, 1, x_125); +return x_126; +} +} +} +else +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; +lean_inc(x_17); +x_127 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_ensureJob___spec__4___rarg), 8, 2); +lean_closure_set(x_127, 0, x_17); +lean_closure_set(x_127, 1, x_1); +x_128 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_ensureJob___spec__5___rarg), 8, 2); +lean_closure_set(x_128, 0, x_17); +lean_closure_set(x_128, 1, x_127); +x_129 = l_IO_withStdin___at_Lake_ensureJob___spec__6___rarg(x_16, x_128, x_3, x_4, x_5, x_6, x_7, x_15); +if (lean_obj_tag(x_129) == 0) +{ +lean_object* x_130; lean_object* x_131; +x_130 = lean_ctor_get(x_129, 0); +lean_inc(x_130); +x_131 = lean_ctor_get(x_130, 0); +lean_inc(x_131); +if (lean_obj_tag(x_131) == 0) +{ +lean_object* x_132; uint8_t x_133; +x_132 = lean_ctor_get(x_129, 1); +lean_inc(x_132); +lean_dec(x_129); +x_133 = !lean_is_exclusive(x_130); +if (x_133 == 0) +{ +lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_134 = lean_ctor_get(x_130, 1); +x_135 = lean_ctor_get(x_130, 0); +lean_dec(x_135); +x_136 = !lean_is_exclusive(x_131); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_137 = lean_ctor_get(x_131, 0); +x_138 = lean_ctor_get(x_131, 1); +x_139 = lean_st_ref_get(x_14, x_132); +lean_dec(x_14); +if (lean_obj_tag(x_139) == 0) +{ +uint8_t x_140; +x_140 = !lean_is_exclusive(x_139); +if (x_140 == 0) +{ +lean_object* x_141; lean_object* x_142; uint8_t x_143; +x_141 = lean_ctor_get(x_139, 0); +x_142 = lean_ctor_get(x_141, 0); +lean_inc(x_142); +lean_dec(x_141); +x_143 = lean_string_validate_utf8(x_142); +if (x_143 == 0) +{ +lean_object* x_144; lean_object* x_145; lean_object* x_146; +lean_dec(x_142); +x_144 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_145 = l_panic___at_String_fromUTF8_x21___spec__1(x_144); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_145); +lean_ctor_set(x_131, 0, x_130); +x_146 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_146, 0, x_131); +lean_ctor_set(x_146, 1, x_134); +lean_ctor_set(x_139, 0, x_146); +return x_139; +} +else +{ +lean_object* x_147; lean_object* x_148; +x_147 = lean_string_from_utf8(x_142); +lean_dec(x_142); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_147); +lean_ctor_set(x_131, 0, x_130); +x_148 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_148, 0, x_131); +lean_ctor_set(x_148, 1, x_134); +lean_ctor_set(x_139, 0, x_148); +return x_139; +} +} +else +{ +lean_object* x_149; lean_object* x_150; lean_object* x_151; uint8_t x_152; +x_149 = lean_ctor_get(x_139, 0); +x_150 = lean_ctor_get(x_139, 1); +lean_inc(x_150); +lean_inc(x_149); +lean_dec(x_139); +x_151 = lean_ctor_get(x_149, 0); +lean_inc(x_151); +lean_dec(x_149); +x_152 = lean_string_validate_utf8(x_151); +if (x_152 == 0) +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_151); +x_153 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_154 = l_panic___at_String_fromUTF8_x21___spec__1(x_153); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_154); +lean_ctor_set(x_131, 0, x_130); +x_155 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_155, 0, x_131); +lean_ctor_set(x_155, 1, x_134); +x_156 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_156, 0, x_155); +lean_ctor_set(x_156, 1, x_150); +return x_156; +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; +x_157 = lean_string_from_utf8(x_151); +lean_dec(x_151); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_157); +lean_ctor_set(x_131, 0, x_130); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_131); +lean_ctor_set(x_158, 1, x_134); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_150); +return x_159; +} +} +} +else +{ +uint8_t x_160; +lean_free_object(x_131); +lean_dec(x_138); +lean_dec(x_137); +lean_free_object(x_130); +lean_dec(x_134); +x_160 = !lean_is_exclusive(x_139); +if (x_160 == 0) +{ +return x_139; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_ctor_get(x_139, 0); +x_162 = lean_ctor_get(x_139, 1); +lean_inc(x_162); +lean_inc(x_161); +lean_dec(x_139); +x_163 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_163, 0, x_161); +lean_ctor_set(x_163, 1, x_162); +return x_163; +} +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; +x_164 = lean_ctor_get(x_131, 0); +x_165 = lean_ctor_get(x_131, 1); +lean_inc(x_165); +lean_inc(x_164); +lean_dec(x_131); +x_166 = lean_st_ref_get(x_14, x_132); +lean_dec(x_14); +if (lean_obj_tag(x_166) == 0) +{ +lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; +x_167 = lean_ctor_get(x_166, 0); +lean_inc(x_167); +x_168 = lean_ctor_get(x_166, 1); +lean_inc(x_168); +if (lean_is_exclusive(x_166)) { + lean_ctor_release(x_166, 0); + lean_ctor_release(x_166, 1); + x_169 = x_166; +} else { + lean_dec_ref(x_166); + x_169 = lean_box(0); +} +x_170 = lean_ctor_get(x_167, 0); +lean_inc(x_170); +lean_dec(x_167); +x_171 = lean_string_validate_utf8(x_170); +if (x_171 == 0) +{ +lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; +lean_dec(x_170); +x_172 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_173 = l_panic___at_String_fromUTF8_x21___spec__1(x_172); +lean_ctor_set(x_130, 1, x_164); +lean_ctor_set(x_130, 0, x_173); +x_174 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_174, 0, x_130); +lean_ctor_set(x_174, 1, x_165); +x_175 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_175, 0, x_174); +lean_ctor_set(x_175, 1, x_134); +if (lean_is_scalar(x_169)) { + x_176 = lean_alloc_ctor(0, 2, 0); +} else { + x_176 = x_169; +} +lean_ctor_set(x_176, 0, x_175); +lean_ctor_set(x_176, 1, x_168); +return x_176; +} +else +{ +lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_177 = lean_string_from_utf8(x_170); +lean_dec(x_170); +lean_ctor_set(x_130, 1, x_164); +lean_ctor_set(x_130, 0, x_177); +x_178 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_178, 0, x_130); +lean_ctor_set(x_178, 1, x_165); +x_179 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_179, 0, x_178); +lean_ctor_set(x_179, 1, x_134); +if (lean_is_scalar(x_169)) { + x_180 = lean_alloc_ctor(0, 2, 0); +} else { + x_180 = x_169; +} +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_168); +return x_180; +} +} +else +{ +lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; +lean_dec(x_165); +lean_dec(x_164); +lean_free_object(x_130); +lean_dec(x_134); +x_181 = lean_ctor_get(x_166, 0); +lean_inc(x_181); +x_182 = lean_ctor_get(x_166, 1); +lean_inc(x_182); +if (lean_is_exclusive(x_166)) { + lean_ctor_release(x_166, 0); + lean_ctor_release(x_166, 1); + x_183 = x_166; +} else { + lean_dec_ref(x_166); + x_183 = lean_box(0); +} +if (lean_is_scalar(x_183)) { + x_184 = lean_alloc_ctor(1, 2, 0); +} else { + x_184 = x_183; +} +lean_ctor_set(x_184, 0, x_181); +lean_ctor_set(x_184, 1, x_182); +return x_184; +} +} +} +else +{ +lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; +x_185 = lean_ctor_get(x_130, 1); +lean_inc(x_185); +lean_dec(x_130); +x_186 = lean_ctor_get(x_131, 0); +lean_inc(x_186); +x_187 = lean_ctor_get(x_131, 1); +lean_inc(x_187); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_188 = x_131; +} else { + lean_dec_ref(x_131); + x_188 = lean_box(0); +} +x_189 = lean_st_ref_get(x_14, x_132); +lean_dec(x_14); +if (lean_obj_tag(x_189) == 0) +{ +lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; uint8_t x_194; +x_190 = lean_ctor_get(x_189, 0); +lean_inc(x_190); +x_191 = lean_ctor_get(x_189, 1); +lean_inc(x_191); +if (lean_is_exclusive(x_189)) { + lean_ctor_release(x_189, 0); + lean_ctor_release(x_189, 1); + x_192 = x_189; +} else { + lean_dec_ref(x_189); + x_192 = lean_box(0); +} +x_193 = lean_ctor_get(x_190, 0); +lean_inc(x_193); +lean_dec(x_190); +x_194 = lean_string_validate_utf8(x_193); +if (x_194 == 0) +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +lean_dec(x_193); +x_195 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5; +x_196 = l_panic___at_String_fromUTF8_x21___spec__1(x_195); +x_197 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_197, 0, x_196); +lean_ctor_set(x_197, 1, x_186); +if (lean_is_scalar(x_188)) { + x_198 = lean_alloc_ctor(0, 2, 0); +} else { + x_198 = x_188; +} +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_187); +x_199 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_199, 0, x_198); +lean_ctor_set(x_199, 1, x_185); +if (lean_is_scalar(x_192)) { + x_200 = lean_alloc_ctor(0, 2, 0); +} else { + x_200 = x_192; +} +lean_ctor_set(x_200, 0, x_199); +lean_ctor_set(x_200, 1, x_191); +return x_200; +} +else +{ +lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; +x_201 = lean_string_from_utf8(x_193); +lean_dec(x_193); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_201); +lean_ctor_set(x_202, 1, x_186); +if (lean_is_scalar(x_188)) { + x_203 = lean_alloc_ctor(0, 2, 0); +} else { + x_203 = x_188; +} +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_187); +x_204 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_204, 0, x_203); +lean_ctor_set(x_204, 1, x_185); +if (lean_is_scalar(x_192)) { + x_205 = lean_alloc_ctor(0, 2, 0); +} else { + x_205 = x_192; +} +lean_ctor_set(x_205, 0, x_204); +lean_ctor_set(x_205, 1, x_191); +return x_205; +} +} +else +{ +lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; +lean_dec(x_188); +lean_dec(x_187); +lean_dec(x_186); +lean_dec(x_185); +x_206 = lean_ctor_get(x_189, 0); +lean_inc(x_206); +x_207 = lean_ctor_get(x_189, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_189)) { + lean_ctor_release(x_189, 0); + lean_ctor_release(x_189, 1); + x_208 = x_189; +} else { + lean_dec_ref(x_189); + x_208 = lean_box(0); +} +if (lean_is_scalar(x_208)) { + x_209 = lean_alloc_ctor(1, 2, 0); +} else { + x_209 = x_208; +} +lean_ctor_set(x_209, 0, x_206); +lean_ctor_set(x_209, 1, x_207); +return x_209; +} +} +} +else +{ +uint8_t x_210; +lean_dec(x_14); +x_210 = !lean_is_exclusive(x_129); +if (x_210 == 0) +{ +lean_object* x_211; uint8_t x_212; +x_211 = lean_ctor_get(x_129, 0); +lean_dec(x_211); +x_212 = !lean_is_exclusive(x_130); +if (x_212 == 0) +{ +lean_object* x_213; uint8_t x_214; +x_213 = lean_ctor_get(x_130, 0); +lean_dec(x_213); +x_214 = !lean_is_exclusive(x_131); +if (x_214 == 0) +{ +return x_129; +} +else +{ +lean_object* x_215; lean_object* x_216; lean_object* x_217; +x_215 = lean_ctor_get(x_131, 0); +x_216 = lean_ctor_get(x_131, 1); +lean_inc(x_216); +lean_inc(x_215); +lean_dec(x_131); +x_217 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_217, 0, x_215); +lean_ctor_set(x_217, 1, x_216); +lean_ctor_set(x_130, 0, x_217); +return x_129; +} +} +else +{ +lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; +x_218 = lean_ctor_get(x_130, 1); +lean_inc(x_218); +lean_dec(x_130); +x_219 = lean_ctor_get(x_131, 0); +lean_inc(x_219); +x_220 = lean_ctor_get(x_131, 1); +lean_inc(x_220); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_221 = x_131; +} else { + lean_dec_ref(x_131); + x_221 = lean_box(0); +} +if (lean_is_scalar(x_221)) { + x_222 = lean_alloc_ctor(1, 2, 0); +} else { + x_222 = x_221; +} +lean_ctor_set(x_222, 0, x_219); +lean_ctor_set(x_222, 1, x_220); +x_223 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_223, 0, x_222); +lean_ctor_set(x_223, 1, x_218); +lean_ctor_set(x_129, 0, x_223); +return x_129; +} +} +else +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +x_224 = lean_ctor_get(x_129, 1); +lean_inc(x_224); +lean_dec(x_129); +x_225 = lean_ctor_get(x_130, 1); +lean_inc(x_225); +if (lean_is_exclusive(x_130)) { + lean_ctor_release(x_130, 0); + lean_ctor_release(x_130, 1); + x_226 = x_130; +} else { + lean_dec_ref(x_130); + x_226 = lean_box(0); +} +x_227 = lean_ctor_get(x_131, 0); +lean_inc(x_227); +x_228 = lean_ctor_get(x_131, 1); +lean_inc(x_228); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_229 = x_131; +} else { + lean_dec_ref(x_131); + x_229 = lean_box(0); +} +if (lean_is_scalar(x_229)) { + x_230 = lean_alloc_ctor(1, 2, 0); +} else { + x_230 = x_229; +} +lean_ctor_set(x_230, 0, x_227); +lean_ctor_set(x_230, 1, x_228); +if (lean_is_scalar(x_226)) { + x_231 = lean_alloc_ctor(0, 2, 0); +} else { + x_231 = x_226; +} +lean_ctor_set(x_231, 0, x_230); +lean_ctor_set(x_231, 1, x_225); +x_232 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_224); +return x_232; +} +} +} +else +{ +uint8_t x_233; +lean_dec(x_14); +x_233 = !lean_is_exclusive(x_129); +if (x_233 == 0) +{ +return x_129; +} +else +{ +lean_object* x_234; lean_object* x_235; lean_object* x_236; +x_234 = lean_ctor_get(x_129, 0); +x_235 = lean_ctor_get(x_129, 1); +lean_inc(x_235); +lean_inc(x_234); +lean_dec(x_129); +x_236 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_236, 0, x_234); +lean_ctor_set(x_236, 1, x_235); +return x_236; +} +} +} +} +else +{ +uint8_t x_237; +lean_dec(x_11); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_237 = !lean_is_exclusive(x_13); +if (x_237 == 0) +{ +return x_13; +} +else +{ +lean_object* x_238; lean_object* x_239; lean_object* x_240; +x_238 = lean_ctor_get(x_13, 0); +x_239 = lean_ctor_get(x_13, 1); +lean_inc(x_239); +lean_inc(x_238); +lean_dec(x_13); +x_240 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_240, 0, x_238); +lean_ctor_set(x_240, 1, x_239); +return x_240; +} +} +} +else +{ +uint8_t x_241; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_241 = !lean_is_exclusive(x_10); +if (x_241 == 0) +{ +return x_10; +} +else +{ +lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_242 = lean_ctor_get(x_10, 0); +x_243 = lean_ctor_get(x_10, 1); +lean_inc(x_243); +lean_inc(x_242); +lean_dec(x_10); +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; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___boxed), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_ctor_get(x_2, 1); +x_5 = !lean_is_exclusive(x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_4, 0); +x_7 = l_Array_append___rarg(x_1, x_6); +lean_dec(x_6); +lean_ctor_set(x_4, 0, x_7); +return x_2; +} +else +{ +lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_4, 0); +x_9 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_8); +lean_dec(x_4); +x_10 = l_Array_append___rarg(x_1, x_8); +lean_dec(x_8); +x_11 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set_uint8(x_11, sizeof(void*)*1, x_9); +lean_ctor_set(x_2, 1, x_11); +return x_2; +} +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_12 = lean_ctor_get(x_2, 1); +x_13 = lean_ctor_get(x_2, 0); +lean_inc(x_12); +lean_inc(x_13); +lean_dec(x_2); +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +x_15 = lean_ctor_get_uint8(x_12, sizeof(void*)*1); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + x_16 = x_12; +} else { + lean_dec_ref(x_12); + x_16 = lean_box(0); +} +x_17 = l_Array_append___rarg(x_1, x_14); +lean_dec(x_14); +if (lean_is_scalar(x_16)) { + x_18 = lean_alloc_ctor(0, 1, 1); +} else { + x_18 = x_16; +} +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set_uint8(x_18, sizeof(void*)*1, x_15); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_13); +lean_ctor_set(x_19, 1, x_18); +return x_19; +} +} +else +{ +uint8_t x_20; +x_20 = !lean_is_exclusive(x_2); +if (x_20 == 0) +{ +lean_object* x_21; uint8_t x_22; +x_21 = lean_ctor_get(x_2, 1); +x_22 = !lean_is_exclusive(x_21); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; +x_23 = lean_ctor_get(x_21, 0); +x_24 = l_Array_append___rarg(x_1, x_23); +lean_dec(x_23); +lean_ctor_set(x_21, 0, x_24); +return x_2; +} +else +{ +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; +x_25 = lean_ctor_get(x_21, 0); +x_26 = lean_ctor_get_uint8(x_21, sizeof(void*)*1); +lean_inc(x_25); +lean_dec(x_21); +x_27 = l_Array_append___rarg(x_1, x_25); +lean_dec(x_25); +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_26); +lean_ctor_set(x_2, 1, x_28); +return x_2; +} +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_29 = lean_ctor_get(x_2, 1); +x_30 = lean_ctor_get(x_2, 0); +lean_inc(x_29); +lean_inc(x_30); +lean_dec(x_2); +x_31 = lean_ctor_get(x_29, 0); +lean_inc(x_31); +x_32 = lean_ctor_get_uint8(x_29, sizeof(void*)*1); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + x_33 = x_29; +} else { + lean_dec_ref(x_29); + x_33 = lean_box(0); +} +x_34 = l_Array_append___rarg(x_1, x_31); +lean_dec(x_31); +if (lean_is_scalar(x_33)) { + x_35 = lean_alloc_ctor(0, 1, 1); +} else { + x_35 = x_33; +} +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set_uint8(x_35, sizeof(void*)*1, x_32); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_30); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_6); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_7); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_8); +return x_11; +} +} +static lean_object* _init_l_Lake_ensureJob___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout/stderr:\n", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_128; lean_object* x_129; +x_8 = lean_array_get_size(x_5); +x_128 = 1; +lean_inc(x_4); +lean_inc(x_3); +lean_inc(x_2); +x_129 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg(x_1, x_128, x_2, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_129) == 0) +{ +lean_object* x_130; lean_object* x_131; +x_130 = lean_ctor_get(x_129, 0); +lean_inc(x_130); +x_131 = lean_ctor_get(x_130, 0); +lean_inc(x_131); +if (lean_obj_tag(x_131) == 0) +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; uint8_t x_138; +x_132 = lean_ctor_get(x_131, 0); +lean_inc(x_132); +x_133 = lean_ctor_get(x_129, 1); +lean_inc(x_133); +lean_dec(x_129); +x_134 = lean_ctor_get(x_130, 1); +lean_inc(x_134); +lean_dec(x_130); +x_135 = lean_ctor_get(x_131, 1); +lean_inc(x_135); +lean_dec(x_131); +x_136 = lean_ctor_get(x_132, 0); +lean_inc(x_136); +x_137 = lean_ctor_get(x_132, 1); +lean_inc(x_137); +lean_dec(x_132); +x_138 = l_String_isEmpty(x_136); +if (x_138 == 0) +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; uint8_t x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; +x_139 = l_Lake_ensureJob___rarg___closed__1; +x_140 = lean_string_append(x_139, x_136); +lean_dec(x_136); +x_141 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_142 = lean_string_append(x_140, x_141); +x_143 = 1; +x_144 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_144, 0, x_142); +lean_ctor_set_uint8(x_144, sizeof(void*)*1, x_143); +x_145 = lean_array_push(x_135, x_144); +x_146 = lean_box(0); +x_147 = l_Lake_ensureJob___rarg___lambda__2(x_137, x_146, x_2, x_3, x_4, x_145, x_134, x_133); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_148 = lean_ctor_get(x_147, 0); +lean_inc(x_148); +x_149 = lean_ctor_get(x_147, 1); +lean_inc(x_149); +lean_dec(x_147); +x_9 = x_148; +x_10 = x_149; +goto block_127; +} +else +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; +lean_dec(x_136); +x_150 = lean_box(0); +x_151 = l_Lake_ensureJob___rarg___lambda__2(x_137, x_150, x_2, x_3, x_4, x_135, x_134, x_133); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_152 = lean_ctor_get(x_151, 0); +lean_inc(x_152); +x_153 = lean_ctor_get(x_151, 1); +lean_inc(x_153); +lean_dec(x_151); +x_9 = x_152; +x_10 = x_153; +goto block_127; +} +} +else +{ +lean_object* x_154; uint8_t x_155; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_154 = lean_ctor_get(x_129, 1); +lean_inc(x_154); +lean_dec(x_129); +x_155 = !lean_is_exclusive(x_130); +if (x_155 == 0) +{ +lean_object* x_156; uint8_t x_157; +x_156 = lean_ctor_get(x_130, 0); +lean_dec(x_156); +x_157 = !lean_is_exclusive(x_131); +if (x_157 == 0) +{ +x_9 = x_130; +x_10 = x_154; +goto block_127; +} +else +{ +lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_158 = lean_ctor_get(x_131, 0); +x_159 = lean_ctor_get(x_131, 1); +lean_inc(x_159); +lean_inc(x_158); +lean_dec(x_131); +x_160 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_160, 0, x_158); +lean_ctor_set(x_160, 1, x_159); +lean_ctor_set(x_130, 0, x_160); +x_9 = x_130; +x_10 = x_154; +goto block_127; +} +} +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; +x_161 = lean_ctor_get(x_130, 1); +lean_inc(x_161); +lean_dec(x_130); +x_162 = lean_ctor_get(x_131, 0); +lean_inc(x_162); +x_163 = lean_ctor_get(x_131, 1); +lean_inc(x_163); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_164 = x_131; +} else { + lean_dec_ref(x_131); + x_164 = lean_box(0); +} +if (lean_is_scalar(x_164)) { + x_165 = lean_alloc_ctor(1, 2, 0); +} else { + x_165 = x_164; +} +lean_ctor_set(x_165, 0, x_162); +lean_ctor_set(x_165, 1, x_163); +x_166 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_166, 0, x_165); +lean_ctor_set(x_166, 1, x_161); +x_9 = x_166; +x_10 = x_154; +goto block_127; +} +} +} +else +{ +uint8_t x_167; +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_167 = !lean_is_exclusive(x_129); +if (x_167 == 0) +{ +return x_129; +} +else +{ +lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_168 = lean_ctor_get(x_129, 0); +x_169 = lean_ctor_get(x_129, 1); +lean_inc(x_169); +lean_inc(x_168); +lean_dec(x_129); +x_170 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_170, 0, x_168); +lean_ctor_set(x_170, 1, x_169); +return x_170; +} +} +block_127: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_9); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_15 = lean_ctor_get(x_11, 0); +x_16 = lean_ctor_get(x_11, 1); +lean_inc(x_16); +x_17 = l_Array_shrink___rarg(x_16, x_8); +x_18 = lean_array_get_size(x_16); +x_19 = l_Array_extract___rarg(x_16, x_8, x_18); +lean_dec(x_18); +lean_dec(x_16); +x_20 = lean_array_get_size(x_19); +x_21 = lean_unsigned_to_nat(0u); +x_22 = lean_nat_dec_eq(x_20, x_21); +lean_dec(x_20); +if (x_22 == 0) +{ +lean_object* x_23; uint8_t x_24; +x_23 = lean_alloc_closure((void*)(l_Lake_ensureJob___rarg___lambda__1), 2, 1); +lean_closure_set(x_23, 0, x_19); +x_24 = !lean_is_exclusive(x_15); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_15, 0); +x_26 = l_Task_Priority_default; +x_27 = 1; +x_28 = lean_task_map(x_23, x_25, x_26, x_27); +lean_ctor_set(x_15, 0, x_28); +lean_ctor_set(x_11, 1, x_17); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_9); +lean_ctor_set(x_29, 1, x_10); +return x_29; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_30 = lean_ctor_get(x_15, 0); +x_31 = lean_ctor_get(x_15, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_15); +x_32 = l_Task_Priority_default; +x_33 = 1; +x_34 = lean_task_map(x_23, x_30, x_32, x_33); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_31); +lean_ctor_set(x_11, 1, x_17); +lean_ctor_set(x_11, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; +lean_dec(x_19); +lean_ctor_set(x_11, 1, x_17); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_9); +lean_ctor_set(x_37, 1, x_10); +return x_37; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; +x_38 = lean_ctor_get(x_11, 0); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_11); +lean_inc(x_39); +x_40 = l_Array_shrink___rarg(x_39, x_8); +x_41 = lean_array_get_size(x_39); +x_42 = l_Array_extract___rarg(x_39, x_8, x_41); +lean_dec(x_41); +lean_dec(x_39); +x_43 = lean_array_get_size(x_42); +x_44 = lean_unsigned_to_nat(0u); +x_45 = lean_nat_dec_eq(x_43, x_44); +lean_dec(x_43); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_46 = lean_alloc_closure((void*)(l_Lake_ensureJob___rarg___lambda__1), 2, 1); +lean_closure_set(x_46, 0, x_42); +x_47 = lean_ctor_get(x_38, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_38, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_38)) { + lean_ctor_release(x_38, 0); + lean_ctor_release(x_38, 1); + x_49 = x_38; +} else { + lean_dec_ref(x_38); + x_49 = lean_box(0); +} +x_50 = l_Task_Priority_default; +x_51 = 1; +x_52 = lean_task_map(x_46, x_47, x_50, x_51); +if (lean_is_scalar(x_49)) { + x_53 = lean_alloc_ctor(0, 2, 0); +} else { + x_53 = x_49; +} +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_40); +lean_ctor_set(x_9, 0, x_54); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_9); +lean_ctor_set(x_55, 1, x_10); +return x_55; +} +else +{ +lean_object* x_56; lean_object* x_57; +lean_dec(x_42); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_40); +lean_ctor_set(x_9, 0, x_56); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_9); +lean_ctor_set(x_57, 1, x_10); +return x_57; +} +} +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; +x_58 = lean_ctor_get(x_9, 1); +lean_inc(x_58); +lean_dec(x_9); +x_59 = lean_ctor_get(x_11, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_11, 1); +lean_inc(x_60); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_61 = x_11; +} else { + lean_dec_ref(x_11); + x_61 = lean_box(0); +} +lean_inc(x_60); +x_62 = l_Array_shrink___rarg(x_60, x_8); +x_63 = lean_array_get_size(x_60); +x_64 = l_Array_extract___rarg(x_60, x_8, x_63); +lean_dec(x_63); +lean_dec(x_60); +x_65 = lean_array_get_size(x_64); +x_66 = lean_unsigned_to_nat(0u); +x_67 = lean_nat_dec_eq(x_65, x_66); +lean_dec(x_65); +if (x_67 == 0) +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_68 = lean_alloc_closure((void*)(l_Lake_ensureJob___rarg___lambda__1), 2, 1); +lean_closure_set(x_68, 0, x_64); +x_69 = lean_ctor_get(x_59, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_59, 1); +lean_inc(x_70); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_71 = x_59; +} else { + lean_dec_ref(x_59); + x_71 = lean_box(0); +} +x_72 = l_Task_Priority_default; +x_73 = 1; +x_74 = lean_task_map(x_68, x_69, x_72, x_73); +if (lean_is_scalar(x_71)) { + x_75 = lean_alloc_ctor(0, 2, 0); +} else { + x_75 = x_71; +} +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_70); +if (lean_is_scalar(x_61)) { + x_76 = lean_alloc_ctor(0, 2, 0); +} else { + x_76 = x_61; +} +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_62); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_58); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_10); +return x_78; +} +else +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_dec(x_64); +if (lean_is_scalar(x_61)) { + x_79 = lean_alloc_ctor(0, 2, 0); +} else { + x_79 = x_61; +} +lean_ctor_set(x_79, 0, x_59); +lean_ctor_set(x_79, 1, x_62); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_58); +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_10); +return x_81; +} +} +} +else +{ +uint8_t x_82; +x_82 = !lean_is_exclusive(x_9); +if (x_82 == 0) +{ +lean_object* x_83; uint8_t x_84; +x_83 = lean_ctor_get(x_9, 0); +lean_dec(x_83); +x_84 = !lean_is_exclusive(x_11); +if (x_84 == 0) +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_85 = lean_ctor_get(x_11, 1); +x_86 = lean_ctor_get(x_11, 0); +lean_dec(x_86); +lean_inc(x_85); +x_87 = l_Array_shrink___rarg(x_85, x_8); +x_88 = lean_array_get_size(x_85); +x_89 = l_Array_extract___rarg(x_85, x_8, x_88); +lean_dec(x_88); +lean_dec(x_85); +x_90 = 0; +x_91 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set_uint8(x_91, sizeof(void*)*1, x_90); +x_92 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_11, 1, x_91); +lean_ctor_set(x_11, 0, x_92); +x_93 = lean_task_pure(x_11); +x_94 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_93); +lean_ctor_set(x_95, 1, x_94); +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_87); +lean_ctor_set(x_9, 0, x_96); +x_97 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_97, 0, x_9); +lean_ctor_set(x_97, 1, x_10); +return x_97; +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; +x_98 = lean_ctor_get(x_11, 1); +lean_inc(x_98); +lean_dec(x_11); +lean_inc(x_98); +x_99 = l_Array_shrink___rarg(x_98, x_8); +x_100 = lean_array_get_size(x_98); +x_101 = l_Array_extract___rarg(x_98, x_8, x_100); +lean_dec(x_100); +lean_dec(x_98); +x_102 = 0; +x_103 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_102); +x_104 = lean_unsigned_to_nat(0u); +x_105 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_105, 0, x_104); +lean_ctor_set(x_105, 1, x_103); +x_106 = lean_task_pure(x_105); +x_107 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_108 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_108, 0, x_106); +lean_ctor_set(x_108, 1, x_107); +x_109 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_109, 0, x_108); +lean_ctor_set(x_109, 1, x_99); +lean_ctor_set(x_9, 0, x_109); +x_110 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_110, 0, x_9); +lean_ctor_set(x_110, 1, x_10); +return x_110; +} +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint8_t x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; +x_111 = lean_ctor_get(x_9, 1); +lean_inc(x_111); +lean_dec(x_9); +x_112 = lean_ctor_get(x_11, 1); +lean_inc(x_112); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_113 = x_11; +} else { + lean_dec_ref(x_11); + x_113 = lean_box(0); +} +lean_inc(x_112); +x_114 = l_Array_shrink___rarg(x_112, x_8); +x_115 = lean_array_get_size(x_112); +x_116 = l_Array_extract___rarg(x_112, x_8, x_115); +lean_dec(x_115); +lean_dec(x_112); +x_117 = 0; +x_118 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_118, 0, x_116); +lean_ctor_set_uint8(x_118, sizeof(void*)*1, x_117); +x_119 = lean_unsigned_to_nat(0u); +if (lean_is_scalar(x_113)) { + x_120 = lean_alloc_ctor(1, 2, 0); +} else { + x_120 = x_113; +} +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_118); +x_121 = lean_task_pure(x_120); +x_122 = l_Lake_buildCycleError___rarg___lambda__1___closed__2; +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_121); +lean_ctor_set(x_123, 1, x_122); +x_124 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_114); +x_125 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_125, 0, x_124); +lean_ctor_set(x_125, 1, x_111); +x_126 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_126, 0, x_125); +lean_ctor_set(x_126, 1, x_10); +return x_126; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_ensureJob(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_ensureJob___rarg), 7, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +uint8_t x_9; lean_object* x_10; +x_9 = lean_unbox(x_2); +lean_dec(x_2); +x_10 = l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg(x_1, x_9, x_3, x_4, x_5, x_6, x_7, x_8); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_ensureJob___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_ensureJob___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_registerJob___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_2); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_10 = lean_ctor_get(x_2, 1); +lean_dec(x_10); +lean_ctor_set(x_2, 1, x_1); +x_11 = lean_ctor_get(x_5, 3); +x_12 = lean_st_ref_take(x_11, x_8); +x_13 = !lean_is_exclusive(x_12); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_14 = lean_ctor_get(x_12, 0); +x_15 = lean_ctor_get(x_12, 1); +lean_inc(x_2); +x_16 = lean_array_push(x_14, x_2); +x_17 = lean_st_ref_set(x_11, x_16, x_15); +x_18 = !lean_is_exclusive(x_17); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_17, 0); +lean_dec(x_19); +x_20 = l_Lake_Job_renew___rarg(x_2); +lean_ctor_set(x_12, 1, x_6); +lean_ctor_set(x_12, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_7); +lean_ctor_set(x_17, 0, x_21); +return x_17; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_17, 1); +lean_inc(x_22); +lean_dec(x_17); +x_23 = l_Lake_Job_renew___rarg(x_2); +lean_ctor_set(x_12, 1, x_6); +lean_ctor_set(x_12, 0, x_23); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_12); +lean_ctor_set(x_24, 1, x_7); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_22); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_26 = lean_ctor_get(x_12, 0); +x_27 = lean_ctor_get(x_12, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_12); +lean_inc(x_2); +x_28 = lean_array_push(x_26, x_2); +x_29 = lean_st_ref_set(x_11, x_28, x_27); +x_30 = lean_ctor_get(x_29, 1); +lean_inc(x_30); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_31 = x_29; +} else { + lean_dec_ref(x_29); + x_31 = lean_box(0); +} +x_32 = l_Lake_Job_renew___rarg(x_2); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_6); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_7); +if (lean_is_scalar(x_31)) { + x_35 = lean_alloc_ctor(0, 2, 0); +} else { + x_35 = x_31; +} +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_30); +return x_35; +} +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_36 = lean_ctor_get(x_2, 0); +lean_inc(x_36); +lean_dec(x_2); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_1); +x_38 = lean_ctor_get(x_5, 3); +x_39 = lean_st_ref_take(x_38, x_8); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_39, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_42 = x_39; +} else { + lean_dec_ref(x_39); + x_42 = lean_box(0); +} +lean_inc(x_37); +x_43 = lean_array_push(x_40, x_37); +x_44 = lean_st_ref_set(x_38, x_43, x_41); +x_45 = lean_ctor_get(x_44, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_46 = x_44; +} else { + lean_dec_ref(x_44); + x_46 = lean_box(0); +} +x_47 = l_Lake_Job_renew___rarg(x_37); +if (lean_is_scalar(x_42)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_42; +} +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_6); +x_49 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_7); +if (lean_is_scalar(x_46)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_46; +} +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_45); +return x_50; +} +} +} +LEAN_EXPORT lean_object* l_Lake_registerJob(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_registerJob___rarg___boxed), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_registerJob___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_registerJob___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_withRegisterJob___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_3); +x_9 = l_Lake_ensureJob___rarg(x_2, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = l_Lake_registerJob___rarg(x_1, x_14, x_3, x_4, x_5, x_15, x_13, x_12); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +return x_16; +} +else +{ +uint8_t x_17; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_17 = !lean_is_exclusive(x_9); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_ctor_get(x_9, 0); +lean_dec(x_18); +x_19 = !lean_is_exclusive(x_10); +if (x_19 == 0) +{ +lean_object* x_20; uint8_t x_21; +x_20 = lean_ctor_get(x_10, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_11); +if (x_21 == 0) +{ +return x_9; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_11); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +lean_ctor_set(x_10, 0, x_24); +return x_9; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 1); +lean_inc(x_25); +lean_dec(x_10); +x_26 = lean_ctor_get(x_11, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_11, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_28 = x_11; +} else { + lean_dec_ref(x_11); + x_28 = lean_box(0); +} +if (lean_is_scalar(x_28)) { + x_29 = lean_alloc_ctor(1, 2, 0); +} else { + x_29 = x_28; +} +lean_ctor_set(x_29, 0, x_26); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 1); +lean_inc(x_32); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_33 = x_10; +} else { + lean_dec_ref(x_10); + x_33 = lean_box(0); +} +x_34 = lean_ctor_get(x_11, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_11, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_36 = x_11; +} else { + lean_dec_ref(x_11); + x_36 = lean_box(0); +} +if (lean_is_scalar(x_36)) { + x_37 = lean_alloc_ctor(1, 2, 0); +} else { + x_37 = x_36; +} +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_35); +if (lean_is_scalar(x_33)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_33; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_32); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_31); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +return x_9; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_9, 0); +x_42 = lean_ctor_get(x_9, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_9); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_withRegisterJob(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_withRegisterJob___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_maybeRegisterJob___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_2, 1); +lean_inc(x_9); +x_10 = l_String_isEmpty(x_9); +lean_dec(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_1); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_2); +lean_ctor_set(x_11, 1, x_6); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_7); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_8); +return x_13; +} +else +{ +lean_object* x_14; +x_14 = l_Lake_registerJob___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +return x_14; +} +} +} +LEAN_EXPORT lean_object* l_Lake_maybeRegisterJob(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_maybeRegisterJob___rarg___boxed), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_maybeRegisterJob___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_maybeRegisterJob___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +return x_9; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Error(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Cycle(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_EquipT(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Info(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Store(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Fetch(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Error(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Cycle(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_EquipT(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Info(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Store(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_buildCycleError___rarg___lambda__1___closed__1 = _init_l_Lake_buildCycleError___rarg___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_buildCycleError___rarg___lambda__1___closed__1); +l_Lake_buildCycleError___rarg___lambda__1___closed__2 = _init_l_Lake_buildCycleError___rarg___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_buildCycleError___rarg___lambda__1___closed__2); +l_Lake_buildCycleError___rarg___closed__1 = _init_l_Lake_buildCycleError___rarg___closed__1(); +lean_mark_persistent(l_Lake_buildCycleError___rarg___closed__1); +l_Lake_buildCycleError___rarg___closed__2 = _init_l_Lake_buildCycleError___rarg___closed__2(); +lean_mark_persistent(l_Lake_buildCycleError___rarg___closed__2); +l_Lake_buildCycleError___rarg___closed__3 = _init_l_Lake_buildCycleError___rarg___closed__3(); +lean_mark_persistent(l_Lake_buildCycleError___rarg___closed__3); +l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__1 = _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__1(); +lean_mark_persistent(l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__1); +l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__2 = _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__2(); +lean_mark_persistent(l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__2); +l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__3 = _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__3(); +lean_mark_persistent(l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__3); +l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__4 = _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__4(); +lean_mark_persistent(l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__4); +l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__5 = _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__5(); +lean_mark_persistent(l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__5); +l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__6 = _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__6(); +lean_mark_persistent(l_Lake_instMonadCycleOfBuildKeyRecBuildM___closed__6); +l_Lake_instMonadCycleOfBuildKeyRecBuildM = _init_l_Lake_instMonadCycleOfBuildKeyRecBuildM(); +lean_mark_persistent(l_Lake_instMonadCycleOfBuildKeyRecBuildM); +l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__1 = _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__1(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__2 = _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__2(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__3 = _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__3(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__3); +l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__4 = _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__4(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__4); +l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5 = _init_l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_ensureJob___spec__1___rarg___closed__5); +l_Lake_ensureJob___rarg___closed__1 = _init_l_Lake_ensureJob___rarg___closed__1(); +lean_mark_persistent(l_Lake_ensureJob___rarg___closed__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Imports.c b/stage0/stdlib/Lake/Build/Imports.c new file mode 100644 index 0000000000..77a27405ae --- /dev/null +++ b/stage0/stdlib/Lake/Build/Imports.c @@ -0,0 +1,8713 @@ +// Lean compiler output +// Module: Lake.Build.Imports +// Imports: Init Lake.Build.Module +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__8(lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__8; +lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(lean_object*, lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___lambda__12___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___lambda__12___closed__2; +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1; +static lean_object* l_Lake_buildImportsAndDeps___closed__3; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__7; +lean_object* l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___closed__6; +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__9(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__8___boxed(lean_object*); +lean_object* lean_get_set_stdout(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__5(lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__11(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_buildImportsAndDeps___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__5; +uint8_t lean_usize_dec_eq(size_t, size_t); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__6(size_t, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15(lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___boxed__const__1; +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_buildImportsAndDeps___spec__6___boxed(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +lean_object* l_Lake_BuildTrace_mix(lean_object*, lean_object*); +uint8_t lean_string_validate_utf8(lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__6; +lean_object* l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__7___boxed(lean_object*); +size_t lean_usize_of_nat(lean_object*); +uint8_t l_String_isEmpty(lean_object*); +lean_object* lean_task_pure(lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___closed__1; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__3; +static lean_object* l_Lake_buildImportsAndDeps___closed__10; +extern lean_object* l_ByteArray_empty; +lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildJob_collectArray___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__3(lean_object*, lean_object*); +lean_object* l_Lake_withRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_st_ref_get(lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__4; +lean_object* lean_st_mk_ref(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_buildImportsAndDeps___spec__6(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_JobState_merge(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_buildImportsAndDeps___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_map_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___closed__4; +lean_object* l_panic___at_String_fromUTF8_x21___spec__1(lean_object*); +lean_object* l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___closed__9; +extern lean_object* l_Task_Priority_default; +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_IO_FS_Stream_ofBuffer(lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___closed__8; +lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___lambda__11___closed__1; +lean_object* lean_get_set_stderr(lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__2; +lean_object* l_Lake_EResult_map___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_from_utf8(lean_object*); +lean_object* l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(lean_object*, lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__10(lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2; +lean_object* l_Lake_EquipT_lift___rarg___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__7(lean_object*); +lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_buildImportsAndDeps___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_OrdHashSet_empty___at_Lake_OrdModuleSet_empty___spec__1; +static lean_object* l_Lake_buildImportsAndDeps___lambda__6___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__2(lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildJob_mixArray___rarg(lean_object*); +lean_object* l_Array_shrink___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__4(lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_task_map(lean_object*, lean_object*, lean_object*, uint8_t); +lean_object* lean_io_bind_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +lean_object* lean_get_set_stdin(lean_object*, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___lambda__12___closed__3; +static lean_object* l_Lake_buildImportsAndDeps___closed__5; +static lean_object* l_Lake_buildImportsAndDeps___lambda__11___closed__2; +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__4; +size_t lean_usize_add(size_t, size_t); +static lean_object* l_Lake_buildImportsAndDeps___closed__7; +lean_object* lean_array_uget(lean_object*, size_t); +static lean_object* l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__1; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__12(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1; +static lean_object* l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__2; +lean_object* lean_array_get_size(lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3; +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7(size_t, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_usize_dec_lt(size_t, size_t); +static lean_object* l_Lake_buildImportsAndDeps___lambda__2___closed__1; +lean_object* lean_nat_add(lean_object*, lean_object*); +static lean_object* l_Lake_buildImportsAndDeps___closed__2; +lean_object* lean_array_uset(lean_object*, size_t, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Array_isEmpty___rarg(lean_object*); +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("olean", 5); +return x_1; +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1(size_t x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = lean_usize_dec_lt(x_2, x_1); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_3); +lean_ctor_set(x_11, 1, x_7); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_14 = lean_array_uget(x_3, x_2); +x_15 = lean_unsigned_to_nat(0u); +x_16 = lean_array_uset(x_3, x_2, x_15); +x_17 = l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__2; +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_14); +lean_ctor_set(x_18, 1, x_17); +lean_inc(x_4); +lean_inc(x_6); +lean_inc(x_5); +x_19 = lean_apply_6(x_4, x_18, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; size_t x_26; size_t x_27; lean_object* x_28; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_21, 1); +lean_inc(x_25); +lean_dec(x_21); +x_26 = 1; +x_27 = lean_usize_add(x_2, x_26); +x_28 = lean_array_uset(x_16, x_2, x_24); +x_2 = x_27; +x_3 = x_28; +x_7 = x_25; +x_8 = x_23; +x_9 = x_22; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_30 = !lean_is_exclusive(x_19); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_19, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_20); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_20, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_21); +if (x_34 == 0) +{ +return x_19; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_21, 0); +x_36 = lean_ctor_get(x_21, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_21); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_20, 0, x_37); +return x_19; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_20, 1); +lean_inc(x_38); +lean_dec(x_20); +x_39 = lean_ctor_get(x_21, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_21, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_41 = x_21; +} else { + lean_dec_ref(x_21); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +lean_ctor_set(x_19, 0, x_43); +return x_19; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +lean_dec(x_19); +x_45 = lean_ctor_get(x_20, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_46 = x_20; +} else { + lean_dec_ref(x_20); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_21, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_21, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_49 = x_21; +} else { + lean_dec_ref(x_21); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +if (lean_is_scalar(x_46)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_46; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_45); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_53 = !lean_is_exclusive(x_19); +if (x_53 == 0) +{ +return x_19; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_19, 0); +x_55 = lean_ctor_get(x_19, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_19); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_buildImportsAndDeps___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_buildImportsAndDeps___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_buildImportsAndDeps___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_ByteArray_empty; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Init.Data.String.Extra", 22); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("String.fromUTF8!", 16); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid UTF-8 string", 20); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5() { +_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_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__2; +x_2 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__3; +x_3 = lean_unsigned_to_nat(92u); +x_4 = lean_unsigned_to_nat(47u); +x_5 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__4; +x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildImportsAndDeps___spec__3), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_buildImportsAndDeps___spec__4(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_buildImportsAndDeps___spec__5), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildImportsAndDeps___spec__3), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_buildImportsAndDeps___spec__4(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildImportsAndDeps___spec__3), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_buildImportsAndDeps___spec__4(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_buildImportsAndDeps___spec__5), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_buildImportsAndDeps___spec__3), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_buildImportsAndDeps___spec__4(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_buildImportsAndDeps___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_3, 0); +x_5 = lean_ctor_get(x_3, 1); +x_6 = lean_ctor_get(x_3, 2); +x_7 = lean_ctor_get(x_3, 3); +lean_inc(x_1); +x_8 = l_Lean_RBNode_fold___at_Lake_buildImportsAndDeps___spec__6(x_1, x_2, x_4); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_5); +lean_ctor_set(x_9, 2, x_6); +x_10 = lean_array_push(x_8, x_9); +x_2 = x_10; +x_3 = x_7; +goto _start; +} +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7(size_t x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; +x_12 = lean_usize_dec_eq(x_3, x_4); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; size_t x_18; lean_object* x_19; +x_13 = lean_array_uget(x_2, x_3); +x_14 = lean_ctor_get(x_13, 10); +lean_inc(x_14); +x_15 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1; +x_16 = l_Lean_RBNode_fold___at_Lake_buildImportsAndDeps___spec__6(x_13, x_15, x_14); +lean_dec(x_14); +x_17 = lean_array_get_size(x_16); +x_18 = lean_usize_of_nat(x_17); +lean_dec(x_17); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_19 = l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2(x_18, x_1, x_16, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; size_t x_27; size_t x_28; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_21, 1); +lean_inc(x_25); +lean_dec(x_21); +x_26 = l_Array_append___rarg(x_5, x_24); +lean_dec(x_24); +x_27 = 1; +x_28 = lean_usize_add(x_3, x_27); +x_3 = x_28; +x_5 = x_26; +x_9 = x_25; +x_10 = x_23; +x_11 = x_22; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_30 = !lean_is_exclusive(x_19); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_19, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_20); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_20, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_21); +if (x_34 == 0) +{ +return x_19; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_21, 0); +x_36 = lean_ctor_get(x_21, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_21); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_20, 0, x_37); +return x_19; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_20, 1); +lean_inc(x_38); +lean_dec(x_20); +x_39 = lean_ctor_get(x_21, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_21, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_41 = x_21; +} else { + lean_dec_ref(x_21); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +lean_ctor_set(x_19, 0, x_43); +return x_19; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +lean_dec(x_19); +x_45 = lean_ctor_get(x_20, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_46 = x_20; +} else { + lean_dec_ref(x_20); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_21, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_21, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_49 = x_21; +} else { + lean_dec_ref(x_21); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +if (lean_is_scalar(x_46)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_46; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_45); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_53 = !lean_is_exclusive(x_19); +if (x_53 == 0) +{ +return x_19; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_19, 0); +x_55 = lean_ctor_get(x_19, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_19); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_5); +lean_ctor_set(x_57, 1, x_9); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_10); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_11); +return x_59; +} +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": bad import '", 14); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("'", 1); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("lean", 4); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("precompileImports", 17); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__4; +x_2 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__5; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("transImports", 12); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__4; +x_2 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__7; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_55; lean_object* x_56; uint8_t x_100; +x_100 = lean_usize_dec_lt(x_4, x_3); +if (x_100 == 0) +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_5); +lean_ctor_set(x_101, 1, x_9); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_10); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_11); +return x_103; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_184; lean_object* x_185; lean_object* x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; +x_104 = lean_array_uget(x_2, x_4); +x_105 = lean_ctor_get(x_5, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_5, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_107 = x_5; +} else { + lean_dec_ref(x_5); + x_107 = lean_box(0); +} +x_246 = lean_ctor_get(x_104, 0); +lean_inc(x_246); +x_247 = lean_ctor_get(x_246, 0); +lean_inc(x_247); +x_248 = lean_ctor_get(x_247, 2); +lean_inc(x_248); +lean_dec(x_247); +x_249 = lean_ctor_get_uint8(x_248, sizeof(void*)*21); +lean_dec(x_248); +if (x_249 == 0) +{ +lean_object* x_250; uint8_t x_251; +x_250 = lean_ctor_get(x_246, 1); +lean_inc(x_250); +lean_dec(x_246); +x_251 = lean_ctor_get_uint8(x_250, sizeof(void*)*9); +lean_dec(x_250); +if (x_251 == 0) +{ +lean_object* x_252; lean_object* x_253; lean_object* x_254; +x_252 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__6; +lean_inc(x_104); +x_253 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_253, 0, x_104); +lean_ctor_set(x_253, 1, x_252); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_254 = lean_apply_6(x_6, x_253, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_254) == 0) +{ +lean_object* x_255; lean_object* x_256; +x_255 = lean_ctor_get(x_254, 0); +lean_inc(x_255); +x_256 = lean_ctor_get(x_255, 0); +lean_inc(x_256); +if (lean_obj_tag(x_256) == 0) +{ +lean_object* x_257; uint8_t x_258; +x_257 = lean_ctor_get(x_254, 1); +lean_inc(x_257); +lean_dec(x_254); +x_258 = !lean_is_exclusive(x_255); +if (x_258 == 0) +{ +lean_object* x_259; lean_object* x_260; uint8_t x_261; +x_259 = lean_ctor_get(x_255, 1); +x_260 = lean_ctor_get(x_255, 0); +lean_dec(x_260); +x_261 = !lean_is_exclusive(x_256); +if (x_261 == 0) +{ +lean_object* x_262; uint8_t x_263; lean_object* x_264; lean_object* x_265; +x_262 = lean_ctor_get(x_256, 0); +x_263 = 0; +x_264 = lean_box(x_263); +lean_ctor_set(x_255, 1, x_262); +lean_ctor_set(x_255, 0, x_264); +lean_ctor_set(x_256, 0, x_255); +x_265 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_265, 0, x_256); +lean_ctor_set(x_265, 1, x_259); +x_184 = x_265; +x_185 = x_257; +goto block_245; +} +else +{ +lean_object* x_266; lean_object* x_267; uint8_t x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; +x_266 = lean_ctor_get(x_256, 0); +x_267 = lean_ctor_get(x_256, 1); +lean_inc(x_267); +lean_inc(x_266); +lean_dec(x_256); +x_268 = 0; +x_269 = lean_box(x_268); +lean_ctor_set(x_255, 1, x_266); +lean_ctor_set(x_255, 0, x_269); +x_270 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_270, 0, x_255); +lean_ctor_set(x_270, 1, x_267); +x_271 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_271, 0, x_270); +lean_ctor_set(x_271, 1, x_259); +x_184 = x_271; +x_185 = x_257; +goto block_245; +} +} +else +{ +lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; uint8_t x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; +x_272 = lean_ctor_get(x_255, 1); +lean_inc(x_272); +lean_dec(x_255); +x_273 = lean_ctor_get(x_256, 0); +lean_inc(x_273); +x_274 = lean_ctor_get(x_256, 1); +lean_inc(x_274); +if (lean_is_exclusive(x_256)) { + lean_ctor_release(x_256, 0); + lean_ctor_release(x_256, 1); + x_275 = x_256; +} else { + lean_dec_ref(x_256); + x_275 = lean_box(0); +} +x_276 = 0; +x_277 = lean_box(x_276); +x_278 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_278, 0, x_277); +lean_ctor_set(x_278, 1, x_273); +if (lean_is_scalar(x_275)) { + x_279 = lean_alloc_ctor(0, 2, 0); +} else { + x_279 = x_275; +} +lean_ctor_set(x_279, 0, x_278); +lean_ctor_set(x_279, 1, x_274); +x_280 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_280, 0, x_279); +lean_ctor_set(x_280, 1, x_272); +x_184 = x_280; +x_185 = x_257; +goto block_245; +} +} +else +{ +lean_object* x_281; uint8_t x_282; +x_281 = lean_ctor_get(x_254, 1); +lean_inc(x_281); +lean_dec(x_254); +x_282 = !lean_is_exclusive(x_255); +if (x_282 == 0) +{ +lean_object* x_283; uint8_t x_284; +x_283 = lean_ctor_get(x_255, 0); +lean_dec(x_283); +x_284 = !lean_is_exclusive(x_256); +if (x_284 == 0) +{ +x_184 = x_255; +x_185 = x_281; +goto block_245; +} +else +{ +lean_object* x_285; lean_object* x_286; lean_object* x_287; +x_285 = lean_ctor_get(x_256, 0); +x_286 = lean_ctor_get(x_256, 1); +lean_inc(x_286); +lean_inc(x_285); +lean_dec(x_256); +x_287 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_287, 0, x_285); +lean_ctor_set(x_287, 1, x_286); +lean_ctor_set(x_255, 0, x_287); +x_184 = x_255; +x_185 = x_281; +goto block_245; +} +} +else +{ +lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; +x_288 = lean_ctor_get(x_255, 1); +lean_inc(x_288); +lean_dec(x_255); +x_289 = lean_ctor_get(x_256, 0); +lean_inc(x_289); +x_290 = lean_ctor_get(x_256, 1); +lean_inc(x_290); +if (lean_is_exclusive(x_256)) { + lean_ctor_release(x_256, 0); + lean_ctor_release(x_256, 1); + x_291 = x_256; +} else { + lean_dec_ref(x_256); + x_291 = lean_box(0); +} +if (lean_is_scalar(x_291)) { + x_292 = lean_alloc_ctor(1, 2, 0); +} else { + x_292 = x_291; +} +lean_ctor_set(x_292, 0, x_289); +lean_ctor_set(x_292, 1, x_290); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_288); +x_184 = x_293; +x_185 = x_281; +goto block_245; +} +} +} +else +{ +uint8_t x_294; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_294 = !lean_is_exclusive(x_254); +if (x_294 == 0) +{ +return x_254; +} +else +{ +lean_object* x_295; lean_object* x_296; lean_object* x_297; +x_295 = lean_ctor_get(x_254, 0); +x_296 = lean_ctor_get(x_254, 1); +lean_inc(x_296); +lean_inc(x_295); +lean_dec(x_254); +x_297 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_297, 0, x_295); +lean_ctor_set(x_297, 1, x_296); +return x_297; +} +} +} +else +{ +lean_object* x_298; lean_object* x_299; lean_object* x_300; +x_298 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__8; +lean_inc(x_104); +x_299 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_299, 0, x_104); +lean_ctor_set(x_299, 1, x_298); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_300 = lean_apply_6(x_6, x_299, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_300) == 0) +{ +lean_object* x_301; lean_object* x_302; +x_301 = lean_ctor_get(x_300, 0); +lean_inc(x_301); +x_302 = lean_ctor_get(x_301, 0); +lean_inc(x_302); +if (lean_obj_tag(x_302) == 0) +{ +lean_object* x_303; uint8_t x_304; +x_303 = lean_ctor_get(x_300, 1); +lean_inc(x_303); +lean_dec(x_300); +x_304 = !lean_is_exclusive(x_301); +if (x_304 == 0) +{ +lean_object* x_305; lean_object* x_306; uint8_t x_307; +x_305 = lean_ctor_get(x_301, 1); +x_306 = lean_ctor_get(x_301, 0); +lean_dec(x_306); +x_307 = !lean_is_exclusive(x_302); +if (x_307 == 0) +{ +lean_object* x_308; uint8_t x_309; lean_object* x_310; lean_object* x_311; +x_308 = lean_ctor_get(x_302, 0); +x_309 = 1; +x_310 = lean_box(x_309); +lean_ctor_set(x_301, 1, x_308); +lean_ctor_set(x_301, 0, x_310); +lean_ctor_set(x_302, 0, x_301); +x_311 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_311, 0, x_302); +lean_ctor_set(x_311, 1, x_305); +x_184 = x_311; +x_185 = x_303; +goto block_245; +} +else +{ +lean_object* x_312; lean_object* x_313; uint8_t x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; +x_312 = lean_ctor_get(x_302, 0); +x_313 = lean_ctor_get(x_302, 1); +lean_inc(x_313); +lean_inc(x_312); +lean_dec(x_302); +x_314 = 1; +x_315 = lean_box(x_314); +lean_ctor_set(x_301, 1, x_312); +lean_ctor_set(x_301, 0, x_315); +x_316 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_316, 0, x_301); +lean_ctor_set(x_316, 1, x_313); +x_317 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_317, 0, x_316); +lean_ctor_set(x_317, 1, x_305); +x_184 = x_317; +x_185 = x_303; +goto block_245; +} +} +else +{ +lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; uint8_t x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; +x_318 = lean_ctor_get(x_301, 1); +lean_inc(x_318); +lean_dec(x_301); +x_319 = lean_ctor_get(x_302, 0); +lean_inc(x_319); +x_320 = lean_ctor_get(x_302, 1); +lean_inc(x_320); +if (lean_is_exclusive(x_302)) { + lean_ctor_release(x_302, 0); + lean_ctor_release(x_302, 1); + x_321 = x_302; +} else { + lean_dec_ref(x_302); + x_321 = lean_box(0); +} +x_322 = 1; +x_323 = lean_box(x_322); +x_324 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_324, 0, x_323); +lean_ctor_set(x_324, 1, x_319); +if (lean_is_scalar(x_321)) { + x_325 = lean_alloc_ctor(0, 2, 0); +} else { + x_325 = x_321; +} +lean_ctor_set(x_325, 0, x_324); +lean_ctor_set(x_325, 1, x_320); +x_326 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_326, 0, x_325); +lean_ctor_set(x_326, 1, x_318); +x_184 = x_326; +x_185 = x_303; +goto block_245; +} +} +else +{ +lean_object* x_327; uint8_t x_328; +x_327 = lean_ctor_get(x_300, 1); +lean_inc(x_327); +lean_dec(x_300); +x_328 = !lean_is_exclusive(x_301); +if (x_328 == 0) +{ +lean_object* x_329; uint8_t x_330; +x_329 = lean_ctor_get(x_301, 0); +lean_dec(x_329); +x_330 = !lean_is_exclusive(x_302); +if (x_330 == 0) +{ +x_184 = x_301; +x_185 = x_327; +goto block_245; +} +else +{ +lean_object* x_331; lean_object* x_332; lean_object* x_333; +x_331 = lean_ctor_get(x_302, 0); +x_332 = lean_ctor_get(x_302, 1); +lean_inc(x_332); +lean_inc(x_331); +lean_dec(x_302); +x_333 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_333, 0, x_331); +lean_ctor_set(x_333, 1, x_332); +lean_ctor_set(x_301, 0, x_333); +x_184 = x_301; +x_185 = x_327; +goto block_245; +} +} +else +{ +lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; +x_334 = lean_ctor_get(x_301, 1); +lean_inc(x_334); +lean_dec(x_301); +x_335 = lean_ctor_get(x_302, 0); +lean_inc(x_335); +x_336 = lean_ctor_get(x_302, 1); +lean_inc(x_336); +if (lean_is_exclusive(x_302)) { + lean_ctor_release(x_302, 0); + lean_ctor_release(x_302, 1); + x_337 = x_302; +} else { + lean_dec_ref(x_302); + x_337 = lean_box(0); +} +if (lean_is_scalar(x_337)) { + x_338 = lean_alloc_ctor(1, 2, 0); +} else { + x_338 = x_337; +} +lean_ctor_set(x_338, 0, x_335); +lean_ctor_set(x_338, 1, x_336); +x_339 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_339, 0, x_338); +lean_ctor_set(x_339, 1, x_334); +x_184 = x_339; +x_185 = x_327; +goto block_245; +} +} +} +else +{ +uint8_t x_340; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_340 = !lean_is_exclusive(x_300); +if (x_340 == 0) +{ +return x_300; +} +else +{ +lean_object* x_341; lean_object* x_342; lean_object* x_343; +x_341 = lean_ctor_get(x_300, 0); +x_342 = lean_ctor_get(x_300, 1); +lean_inc(x_342); +lean_inc(x_341); +lean_dec(x_300); +x_343 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_343, 0, x_341); +lean_ctor_set(x_343, 1, x_342); +return x_343; +} +} +} +} +else +{ +lean_object* x_344; lean_object* x_345; lean_object* x_346; +lean_dec(x_246); +x_344 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__8; +lean_inc(x_104); +x_345 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_345, 0, x_104); +lean_ctor_set(x_345, 1, x_344); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_346 = lean_apply_6(x_6, x_345, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_346) == 0) +{ +lean_object* x_347; lean_object* x_348; +x_347 = lean_ctor_get(x_346, 0); +lean_inc(x_347); +x_348 = lean_ctor_get(x_347, 0); +lean_inc(x_348); +if (lean_obj_tag(x_348) == 0) +{ +lean_object* x_349; uint8_t x_350; +x_349 = lean_ctor_get(x_346, 1); +lean_inc(x_349); +lean_dec(x_346); +x_350 = !lean_is_exclusive(x_347); +if (x_350 == 0) +{ +lean_object* x_351; lean_object* x_352; uint8_t x_353; +x_351 = lean_ctor_get(x_347, 1); +x_352 = lean_ctor_get(x_347, 0); +lean_dec(x_352); +x_353 = !lean_is_exclusive(x_348); +if (x_353 == 0) +{ +lean_object* x_354; uint8_t x_355; lean_object* x_356; lean_object* x_357; +x_354 = lean_ctor_get(x_348, 0); +x_355 = 1; +x_356 = lean_box(x_355); +lean_ctor_set(x_347, 1, x_354); +lean_ctor_set(x_347, 0, x_356); +lean_ctor_set(x_348, 0, x_347); +x_357 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_357, 0, x_348); +lean_ctor_set(x_357, 1, x_351); +x_184 = x_357; +x_185 = x_349; +goto block_245; +} +else +{ +lean_object* x_358; lean_object* x_359; uint8_t x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; +x_358 = lean_ctor_get(x_348, 0); +x_359 = lean_ctor_get(x_348, 1); +lean_inc(x_359); +lean_inc(x_358); +lean_dec(x_348); +x_360 = 1; +x_361 = lean_box(x_360); +lean_ctor_set(x_347, 1, x_358); +lean_ctor_set(x_347, 0, x_361); +x_362 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_362, 0, x_347); +lean_ctor_set(x_362, 1, x_359); +x_363 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_363, 0, x_362); +lean_ctor_set(x_363, 1, x_351); +x_184 = x_363; +x_185 = x_349; +goto block_245; +} +} +else +{ +lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; uint8_t x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; +x_364 = lean_ctor_get(x_347, 1); +lean_inc(x_364); +lean_dec(x_347); +x_365 = lean_ctor_get(x_348, 0); +lean_inc(x_365); +x_366 = lean_ctor_get(x_348, 1); +lean_inc(x_366); +if (lean_is_exclusive(x_348)) { + lean_ctor_release(x_348, 0); + lean_ctor_release(x_348, 1); + x_367 = x_348; +} else { + lean_dec_ref(x_348); + x_367 = lean_box(0); +} +x_368 = 1; +x_369 = lean_box(x_368); +x_370 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_370, 0, x_369); +lean_ctor_set(x_370, 1, x_365); +if (lean_is_scalar(x_367)) { + x_371 = lean_alloc_ctor(0, 2, 0); +} else { + x_371 = x_367; +} +lean_ctor_set(x_371, 0, x_370); +lean_ctor_set(x_371, 1, x_366); +x_372 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_372, 0, x_371); +lean_ctor_set(x_372, 1, x_364); +x_184 = x_372; +x_185 = x_349; +goto block_245; +} +} +else +{ +lean_object* x_373; uint8_t x_374; +x_373 = lean_ctor_get(x_346, 1); +lean_inc(x_373); +lean_dec(x_346); +x_374 = !lean_is_exclusive(x_347); +if (x_374 == 0) +{ +lean_object* x_375; uint8_t x_376; +x_375 = lean_ctor_get(x_347, 0); +lean_dec(x_375); +x_376 = !lean_is_exclusive(x_348); +if (x_376 == 0) +{ +x_184 = x_347; +x_185 = x_373; +goto block_245; +} +else +{ +lean_object* x_377; lean_object* x_378; lean_object* x_379; +x_377 = lean_ctor_get(x_348, 0); +x_378 = lean_ctor_get(x_348, 1); +lean_inc(x_378); +lean_inc(x_377); +lean_dec(x_348); +x_379 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_379, 0, x_377); +lean_ctor_set(x_379, 1, x_378); +lean_ctor_set(x_347, 0, x_379); +x_184 = x_347; +x_185 = x_373; +goto block_245; +} +} +else +{ +lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; +x_380 = lean_ctor_get(x_347, 1); +lean_inc(x_380); +lean_dec(x_347); +x_381 = lean_ctor_get(x_348, 0); +lean_inc(x_381); +x_382 = lean_ctor_get(x_348, 1); +lean_inc(x_382); +if (lean_is_exclusive(x_348)) { + lean_ctor_release(x_348, 0); + lean_ctor_release(x_348, 1); + x_383 = x_348; +} else { + lean_dec_ref(x_348); + x_383 = lean_box(0); +} +if (lean_is_scalar(x_383)) { + x_384 = lean_alloc_ctor(1, 2, 0); +} else { + x_384 = x_383; +} +lean_ctor_set(x_384, 0, x_381); +lean_ctor_set(x_384, 1, x_382); +x_385 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_385, 0, x_384); +lean_ctor_set(x_385, 1, x_380); +x_184 = x_385; +x_185 = x_373; +goto block_245; +} +} +} +else +{ +uint8_t x_386; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_386 = !lean_is_exclusive(x_346); +if (x_386 == 0) +{ +return x_346; +} +else +{ +lean_object* x_387; lean_object* x_388; lean_object* x_389; +x_387 = lean_ctor_get(x_346, 0); +x_388 = lean_ctor_get(x_346, 1); +lean_inc(x_388); +lean_inc(x_387); +lean_dec(x_346); +x_389 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_389, 0, x_387); +lean_ctor_set(x_389, 1, x_388); +return x_389; +} +} +} +block_183: +{ +lean_object* x_110; +x_110 = lean_ctor_get(x_108, 0); +lean_inc(x_110); +if (lean_obj_tag(x_110) == 0) +{ +uint8_t x_111; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_104); +x_111 = !lean_is_exclusive(x_108); +if (x_111 == 0) +{ +lean_object* x_112; +x_112 = lean_ctor_get(x_108, 0); +lean_dec(x_112); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_113; lean_object* x_114; +x_113 = lean_ctor_get(x_108, 1); +lean_inc(x_113); +lean_dec(x_108); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_110); +lean_ctor_set(x_114, 1, x_113); +x_55 = x_114; +x_56 = x_109; +goto block_99; +} +} +else +{ +uint8_t x_115; +x_115 = !lean_is_exclusive(x_108); +if (x_115 == 0) +{ +lean_object* x_116; uint8_t x_117; +x_116 = lean_ctor_get(x_108, 0); +lean_dec(x_116); +x_117 = !lean_is_exclusive(x_110); +if (x_117 == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_118 = lean_ctor_get(x_110, 0); +x_119 = lean_ctor_get(x_110, 1); +x_120 = l_Array_shrink___rarg(x_119, x_118); +lean_dec(x_118); +x_121 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1; +x_122 = lean_string_append(x_121, x_1); +x_123 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2; +x_124 = lean_string_append(x_122, x_123); +x_125 = lean_ctor_get(x_104, 1); +lean_inc(x_125); +lean_dec(x_104); +x_126 = 1; +x_127 = l_Lean_Name_toString(x_125, x_126); +x_128 = lean_string_append(x_124, x_127); +lean_dec(x_127); +x_129 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3; +x_130 = lean_string_append(x_128, x_129); +x_131 = 3; +x_132 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set_uint8(x_132, sizeof(void*)*1, x_131); +x_133 = lean_array_push(x_120, x_132); +x_134 = lean_box(x_126); +if (lean_is_scalar(x_107)) { + x_135 = lean_alloc_ctor(0, 2, 0); +} else { + x_135 = x_107; +} +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_106); +x_136 = lean_box(0); +x_137 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_135); +lean_ctor_set_tag(x_110, 0); +lean_ctor_set(x_110, 1, x_133); +lean_ctor_set(x_110, 0, x_137); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +x_138 = lean_ctor_get(x_110, 0); +x_139 = lean_ctor_get(x_110, 1); +lean_inc(x_139); +lean_inc(x_138); +lean_dec(x_110); +x_140 = l_Array_shrink___rarg(x_139, x_138); +lean_dec(x_138); +x_141 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1; +x_142 = lean_string_append(x_141, x_1); +x_143 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2; +x_144 = lean_string_append(x_142, x_143); +x_145 = lean_ctor_get(x_104, 1); +lean_inc(x_145); +lean_dec(x_104); +x_146 = 1; +x_147 = l_Lean_Name_toString(x_145, x_146); +x_148 = lean_string_append(x_144, x_147); +lean_dec(x_147); +x_149 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3; +x_150 = lean_string_append(x_148, x_149); +x_151 = 3; +x_152 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set_uint8(x_152, sizeof(void*)*1, x_151); +x_153 = lean_array_push(x_140, x_152); +x_154 = lean_box(x_146); +if (lean_is_scalar(x_107)) { + x_155 = lean_alloc_ctor(0, 2, 0); +} else { + x_155 = x_107; +} +lean_ctor_set(x_155, 0, x_154); +lean_ctor_set(x_155, 1, x_106); +x_156 = lean_box(0); +x_157 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_157, 0, x_156); +lean_ctor_set(x_157, 1, x_155); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_157); +lean_ctor_set(x_158, 1, x_153); +lean_ctor_set(x_108, 0, x_158); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; uint8_t x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; +x_159 = lean_ctor_get(x_108, 1); +lean_inc(x_159); +lean_dec(x_108); +x_160 = lean_ctor_get(x_110, 0); +lean_inc(x_160); +x_161 = lean_ctor_get(x_110, 1); +lean_inc(x_161); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_162 = x_110; +} else { + lean_dec_ref(x_110); + x_162 = lean_box(0); +} +x_163 = l_Array_shrink___rarg(x_161, x_160); +lean_dec(x_160); +x_164 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1; +x_165 = lean_string_append(x_164, x_1); +x_166 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2; +x_167 = lean_string_append(x_165, x_166); +x_168 = lean_ctor_get(x_104, 1); +lean_inc(x_168); +lean_dec(x_104); +x_169 = 1; +x_170 = l_Lean_Name_toString(x_168, x_169); +x_171 = lean_string_append(x_167, x_170); +lean_dec(x_170); +x_172 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3; +x_173 = lean_string_append(x_171, x_172); +x_174 = 3; +x_175 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_175, 0, x_173); +lean_ctor_set_uint8(x_175, sizeof(void*)*1, x_174); +x_176 = lean_array_push(x_163, x_175); +x_177 = lean_box(x_169); +if (lean_is_scalar(x_107)) { + x_178 = lean_alloc_ctor(0, 2, 0); +} else { + x_178 = x_107; +} +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_106); +x_179 = lean_box(0); +x_180 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_178); +if (lean_is_scalar(x_162)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_162; + lean_ctor_set_tag(x_181, 0); +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_176); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_159); +x_55 = x_182; +x_56 = x_109; +goto block_99; +} +} +} +block_245: +{ +lean_object* x_186; +x_186 = lean_ctor_get(x_184, 0); +lean_inc(x_186); +if (lean_obj_tag(x_186) == 0) +{ +lean_object* x_187; lean_object* x_188; uint8_t x_189; +x_187 = lean_ctor_get(x_186, 0); +lean_inc(x_187); +x_188 = lean_ctor_get(x_184, 1); +lean_inc(x_188); +lean_dec(x_184); +x_189 = !lean_is_exclusive(x_186); +if (x_189 == 0) +{ +lean_object* x_190; uint8_t x_191; +x_190 = lean_ctor_get(x_186, 0); +lean_dec(x_190); +x_191 = !lean_is_exclusive(x_187); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; +x_192 = lean_ctor_get(x_187, 0); +x_193 = lean_ctor_get(x_187, 1); +lean_inc(x_106); +x_194 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_193); +lean_dec(x_193); +x_195 = lean_unbox(x_192); +lean_dec(x_192); +if (x_195 == 0) +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; +x_196 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_196, 0, x_105); +lean_ctor_set(x_196, 1, x_194); +x_197 = lean_box(0); +x_198 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_196); +lean_ctor_set(x_186, 0, x_198); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; +lean_inc(x_104); +x_199 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_194, x_104); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_105); +lean_ctor_set(x_200, 1, x_199); +x_201 = lean_box(0); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_201); +lean_ctor_set(x_202, 1, x_200); +lean_ctor_set(x_186, 0, x_202); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_203; lean_object* x_204; lean_object* x_205; uint8_t x_206; +x_203 = lean_ctor_get(x_187, 0); +x_204 = lean_ctor_get(x_187, 1); +lean_inc(x_204); +lean_inc(x_203); +lean_dec(x_187); +lean_inc(x_106); +x_205 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_204); +lean_dec(x_204); +x_206 = lean_unbox(x_203); +lean_dec(x_203); +if (x_206 == 0) +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +x_207 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_207, 0, x_105); +lean_ctor_set(x_207, 1, x_205); +x_208 = lean_box(0); +x_209 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_209, 0, x_208); +lean_ctor_set(x_209, 1, x_207); +lean_ctor_set(x_186, 0, x_209); +x_210 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_210, 0, x_186); +lean_ctor_set(x_210, 1, x_188); +x_108 = x_210; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +lean_inc(x_104); +x_211 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_205, x_104); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_105); +lean_ctor_set(x_212, 1, x_211); +x_213 = lean_box(0); +x_214 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_214, 0, x_213); +lean_ctor_set(x_214, 1, x_212); +lean_ctor_set(x_186, 0, x_214); +x_215 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_215, 0, x_186); +lean_ctor_set(x_215, 1, x_188); +x_108 = x_215; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; uint8_t x_221; +x_216 = lean_ctor_get(x_186, 1); +lean_inc(x_216); +lean_dec(x_186); +x_217 = lean_ctor_get(x_187, 0); +lean_inc(x_217); +x_218 = lean_ctor_get(x_187, 1); +lean_inc(x_218); +if (lean_is_exclusive(x_187)) { + lean_ctor_release(x_187, 0); + lean_ctor_release(x_187, 1); + x_219 = x_187; +} else { + lean_dec_ref(x_187); + x_219 = lean_box(0); +} +lean_inc(x_106); +x_220 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_218); +lean_dec(x_218); +x_221 = lean_unbox(x_217); +lean_dec(x_217); +if (x_221 == 0) +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_222 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_222, 0, x_105); +lean_ctor_set(x_222, 1, x_220); +x_223 = lean_box(0); +x_224 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_224, 0, x_223); +lean_ctor_set(x_224, 1, x_222); +x_225 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_225, 0, x_224); +lean_ctor_set(x_225, 1, x_216); +if (lean_is_scalar(x_219)) { + x_226 = lean_alloc_ctor(0, 2, 0); +} else { + x_226 = x_219; +} +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_188); +x_108 = x_226; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +lean_inc(x_104); +x_227 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_220, x_104); +x_228 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_228, 0, x_105); +lean_ctor_set(x_228, 1, x_227); +x_229 = lean_box(0); +x_230 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_230, 0, x_229); +lean_ctor_set(x_230, 1, x_228); +x_231 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_231, 0, x_230); +lean_ctor_set(x_231, 1, x_216); +if (lean_is_scalar(x_219)) { + x_232 = lean_alloc_ctor(0, 2, 0); +} else { + x_232 = x_219; +} +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_188); +x_108 = x_232; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +uint8_t x_233; +lean_dec(x_105); +x_233 = !lean_is_exclusive(x_184); +if (x_233 == 0) +{ +lean_object* x_234; uint8_t x_235; +x_234 = lean_ctor_get(x_184, 0); +lean_dec(x_234); +x_235 = !lean_is_exclusive(x_186); +if (x_235 == 0) +{ +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_236; lean_object* x_237; lean_object* x_238; +x_236 = lean_ctor_get(x_186, 0); +x_237 = lean_ctor_get(x_186, 1); +lean_inc(x_237); +lean_inc(x_236); +lean_dec(x_186); +x_238 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_238, 0, x_236); +lean_ctor_set(x_238, 1, x_237); +lean_ctor_set(x_184, 0, x_238); +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_239 = lean_ctor_get(x_184, 1); +lean_inc(x_239); +lean_dec(x_184); +x_240 = lean_ctor_get(x_186, 0); +lean_inc(x_240); +x_241 = lean_ctor_get(x_186, 1); +lean_inc(x_241); +if (lean_is_exclusive(x_186)) { + lean_ctor_release(x_186, 0); + lean_ctor_release(x_186, 1); + x_242 = x_186; +} else { + lean_dec_ref(x_186); + x_242 = lean_box(0); +} +if (lean_is_scalar(x_242)) { + x_243 = lean_alloc_ctor(1, 2, 0); +} else { + x_243 = x_242; +} +lean_ctor_set(x_243, 0, x_240); +lean_ctor_set(x_243, 1, x_241); +x_244 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_244, 0, x_243); +lean_ctor_set(x_244, 1, x_239); +x_108 = x_244; +x_109 = x_185; +goto block_183; +} +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +block_99: +{ +lean_object* x_57; +x_57 = lean_ctor_get(x_55, 0); +lean_inc(x_57); +if (lean_obj_tag(x_57) == 0) +{ +lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_58 = lean_ctor_get(x_57, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = !lean_is_exclusive(x_55); +if (x_60 == 0) +{ +lean_object* x_61; uint8_t x_62; +x_61 = lean_ctor_get(x_55, 0); +lean_dec(x_61); +x_62 = !lean_is_exclusive(x_57); +if (x_62 == 0) +{ +lean_object* x_63; uint8_t x_64; +x_63 = lean_ctor_get(x_57, 0); +lean_dec(x_63); +x_64 = !lean_is_exclusive(x_59); +if (x_64 == 0) +{ +lean_object* x_65; +x_65 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_65, 0, x_59); +lean_ctor_set(x_57, 0, x_65); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_66 = lean_ctor_get(x_59, 0); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_59); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +x_69 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_57, 0, x_69); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_70 = lean_ctor_get(x_57, 1); +lean_inc(x_70); +lean_dec(x_57); +x_71 = lean_ctor_get(x_59, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_59, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_73 = x_59; +} else { + lean_dec_ref(x_59); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +x_75 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_75, 0, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_70); +lean_ctor_set(x_55, 0, x_76); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_77 = lean_ctor_get(x_55, 1); +lean_inc(x_77); +lean_dec(x_55); +x_78 = lean_ctor_get(x_57, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_79 = x_57; +} else { + lean_dec_ref(x_57); + x_79 = lean_box(0); +} +x_80 = lean_ctor_get(x_59, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_59, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_82 = x_59; +} else { + lean_dec_ref(x_59); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_82)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_82; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_81); +x_84 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_84, 0, x_83); +if (lean_is_scalar(x_79)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_79; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_78); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_12 = x_86; +x_13 = x_56; +goto block_54; +} +} +else +{ +uint8_t x_87; +x_87 = !lean_is_exclusive(x_55); +if (x_87 == 0) +{ +lean_object* x_88; uint8_t x_89; +x_88 = lean_ctor_get(x_55, 0); +lean_dec(x_88); +x_89 = !lean_is_exclusive(x_57); +if (x_89 == 0) +{ +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_57, 0); +x_91 = lean_ctor_get(x_57, 1); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_57); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set(x_92, 1, x_91); +lean_ctor_set(x_55, 0, x_92); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_93 = lean_ctor_get(x_55, 1); +lean_inc(x_93); +lean_dec(x_55); +x_94 = lean_ctor_get(x_57, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_57, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_96 = x_57; +} else { + lean_dec_ref(x_57); + x_96 = lean_box(0); +} +if (lean_is_scalar(x_96)) { + x_97 = lean_alloc_ctor(1, 2, 0); +} else { + x_97 = x_96; +} +lean_ctor_set(x_97, 0, x_94); +lean_ctor_set(x_97, 1, x_95); +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_93); +x_12 = x_98; +x_13 = x_56; +goto block_54; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_4); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout/stderr:\n", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__2(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = !lean_is_exclusive(x_8); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; size_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; +x_11 = lean_ctor_get(x_8, 0); +x_12 = lean_ctor_get(x_8, 1); +x_13 = l_Array_append___rarg(x_11, x_1); +x_14 = lean_array_get_size(x_13); +x_15 = lean_usize_of_nat(x_14); +lean_dec(x_14); +x_16 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(x_15, x_2, x_13); +x_17 = l_Lake_BuildTrace_mix(x_3, x_4); +x_18 = l_Lake_BuildTrace_mix(x_17, x_12); +lean_ctor_set(x_8, 1, x_18); +lean_ctor_set(x_8, 0, x_16); +x_19 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_19, 0, x_8); +x_20 = 1; +lean_inc(x_5); +x_21 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2(x_19, x_20, x_5, x_9, x_7); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; +x_22 = lean_ctor_get(x_21, 0); +lean_inc(x_22); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_21, 1); +lean_inc(x_24); +lean_dec(x_21); +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +lean_dec(x_22); +x_26 = lean_ctor_get(x_23, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_23, 1); +lean_inc(x_27); +lean_dec(x_23); +x_28 = l_String_isEmpty(x_26); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; uint8_t x_35; +x_29 = l_Lake_buildImportsAndDeps___lambda__2___closed__1; +x_30 = lean_string_append(x_29, x_26); +lean_dec(x_26); +x_31 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1; +x_32 = lean_string_append(x_30, x_31); +x_33 = 1; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = !lean_is_exclusive(x_25); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = lean_ctor_get(x_25, 0); +x_37 = lean_array_push(x_36, x_34); +lean_ctor_set(x_25, 0, x_37); +x_38 = lean_box(0); +x_39 = l_Lake_buildImportsAndDeps___lambda__1(x_27, x_38, x_5, x_25, x_24); +lean_dec(x_5); +return x_39; +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_40 = lean_ctor_get(x_25, 0); +x_41 = lean_ctor_get_uint8(x_25, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_25); +x_42 = lean_array_push(x_40, x_34); +x_43 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set_uint8(x_43, sizeof(void*)*1, x_41); +x_44 = lean_box(0); +x_45 = l_Lake_buildImportsAndDeps___lambda__1(x_27, x_44, x_5, x_43, x_24); +lean_dec(x_5); +return x_45; +} +} +else +{ +lean_object* x_46; lean_object* x_47; +lean_dec(x_26); +x_46 = lean_box(0); +x_47 = l_Lake_buildImportsAndDeps___lambda__1(x_27, x_46, x_5, x_25, x_24); +lean_dec(x_5); +return x_47; +} +} +else +{ +uint8_t x_48; +lean_dec(x_5); +x_48 = !lean_is_exclusive(x_21); +if (x_48 == 0) +{ +lean_object* x_49; uint8_t x_50; +x_49 = lean_ctor_get(x_21, 0); +lean_dec(x_49); +x_50 = !lean_is_exclusive(x_22); +if (x_50 == 0) +{ +return x_21; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_22, 0); +x_52 = lean_ctor_get(x_22, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_22); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +lean_ctor_set(x_21, 0, x_53); +return x_21; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_54 = lean_ctor_get(x_21, 1); +lean_inc(x_54); +lean_dec(x_21); +x_55 = lean_ctor_get(x_22, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_22, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_57 = x_22; +} else { + lean_dec_ref(x_22); + x_57 = lean_box(0); +} +if (lean_is_scalar(x_57)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_57; +} +lean_ctor_set(x_58, 0, x_55); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_54); +return x_59; +} +} +} +else +{ +uint8_t x_60; +lean_dec(x_5); +x_60 = !lean_is_exclusive(x_21); +if (x_60 == 0) +{ +return x_21; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_61 = lean_ctor_get(x_21, 0); +x_62 = lean_ctor_get(x_21, 1); +lean_inc(x_62); +lean_inc(x_61); +lean_dec(x_21); +x_63 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set(x_63, 1, x_62); +return x_63; +} +} +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; size_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; +x_64 = lean_ctor_get(x_8, 0); +x_65 = lean_ctor_get(x_8, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_8); +x_66 = l_Array_append___rarg(x_64, x_1); +x_67 = lean_array_get_size(x_66); +x_68 = lean_usize_of_nat(x_67); +lean_dec(x_67); +x_69 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(x_68, x_2, x_66); +x_70 = l_Lake_BuildTrace_mix(x_3, x_4); +x_71 = l_Lake_BuildTrace_mix(x_70, x_65); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_69); +lean_ctor_set(x_72, 1, x_71); +x_73 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_73, 0, x_72); +x_74 = 1; +lean_inc(x_5); +x_75 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2(x_73, x_74, x_5, x_9, x_7); +if (lean_obj_tag(x_75) == 0) +{ +lean_object* x_76; +x_76 = lean_ctor_get(x_75, 0); +lean_inc(x_76); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_75, 1); +lean_inc(x_78); +lean_dec(x_75); +x_79 = lean_ctor_get(x_76, 1); +lean_inc(x_79); +lean_dec(x_76); +x_80 = lean_ctor_get(x_77, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_77, 1); +lean_inc(x_81); +lean_dec(x_77); +x_82 = l_String_isEmpty(x_80); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; uint8_t x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_83 = l_Lake_buildImportsAndDeps___lambda__2___closed__1; +x_84 = lean_string_append(x_83, x_80); +lean_dec(x_80); +x_85 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1; +x_86 = lean_string_append(x_84, x_85); +x_87 = 1; +x_88 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_88, 0, x_86); +lean_ctor_set_uint8(x_88, sizeof(void*)*1, x_87); +x_89 = lean_ctor_get(x_79, 0); +lean_inc(x_89); +x_90 = lean_ctor_get_uint8(x_79, sizeof(void*)*1); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + x_91 = x_79; +} else { + lean_dec_ref(x_79); + x_91 = lean_box(0); +} +x_92 = lean_array_push(x_89, x_88); +if (lean_is_scalar(x_91)) { + x_93 = lean_alloc_ctor(0, 1, 1); +} else { + x_93 = x_91; +} +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set_uint8(x_93, sizeof(void*)*1, x_90); +x_94 = lean_box(0); +x_95 = l_Lake_buildImportsAndDeps___lambda__1(x_81, x_94, x_5, x_93, x_78); +lean_dec(x_5); +return x_95; +} +else +{ +lean_object* x_96; lean_object* x_97; +lean_dec(x_80); +x_96 = lean_box(0); +x_97 = l_Lake_buildImportsAndDeps___lambda__1(x_81, x_96, x_5, x_79, x_78); +lean_dec(x_5); +return x_97; +} +} +else +{ +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_dec(x_5); +x_98 = lean_ctor_get(x_75, 1); +lean_inc(x_98); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + lean_ctor_release(x_75, 1); + x_99 = x_75; +} else { + lean_dec_ref(x_75); + x_99 = lean_box(0); +} +x_100 = lean_ctor_get(x_76, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_76, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_102 = x_76; +} else { + lean_dec_ref(x_76); + x_102 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_103 = lean_alloc_ctor(1, 2, 0); +} else { + x_103 = x_102; +} +lean_ctor_set(x_103, 0, x_100); +lean_ctor_set(x_103, 1, x_101); +if (lean_is_scalar(x_99)) { + x_104 = lean_alloc_ctor(0, 2, 0); +} else { + x_104 = x_99; +} +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_98); +return x_104; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_5); +x_105 = lean_ctor_get(x_75, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_75, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + lean_ctor_release(x_75, 1); + x_107 = x_75; +} else { + lean_dec_ref(x_75); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +x_109 = !lean_is_exclusive(x_6); +if (x_109 == 0) +{ +lean_object* x_110; +x_110 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_110, 0, x_6); +lean_ctor_set(x_110, 1, x_7); +return x_110; +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; +x_111 = lean_ctor_get(x_6, 0); +x_112 = lean_ctor_get(x_6, 1); +lean_inc(x_112); +lean_inc(x_111); +lean_dec(x_6); +x_113 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_113, 0, x_111); +lean_ctor_set(x_113, 1, x_112); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_114, 1, x_7); +return x_114; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__3(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 1); +x_5 = l_Lake_JobState_merge(x_1, x_4); +lean_ctor_set(x_2, 1, x_5); +return x_2; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +lean_inc(x_7); +lean_inc(x_6); +lean_dec(x_2); +x_8 = l_Lake_JobState_merge(x_1, x_7); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_6); +lean_ctor_set(x_9, 1, x_8); +return x_9; +} +} +else +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_2); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get(x_2, 1); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = lean_array_get_size(x_13); +lean_dec(x_13); +x_15 = lean_nat_add(x_14, x_11); +lean_dec(x_11); +lean_dec(x_14); +x_16 = l_Lake_JobState_merge(x_1, x_12); +lean_ctor_set(x_2, 1, x_16); +lean_ctor_set(x_2, 0, x_15); +return x_2; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_2, 0); +x_18 = lean_ctor_get(x_2, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_2); +x_19 = lean_ctor_get(x_1, 0); +lean_inc(x_19); +x_20 = lean_array_get_size(x_19); +lean_dec(x_19); +x_21 = lean_nat_add(x_20, x_17); +lean_dec(x_17); +lean_dec(x_20); +x_22 = l_Lake_JobState_merge(x_1, x_18); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__4(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_ctor_get(x_1, 0); +lean_inc(x_11); +lean_dec(x_1); +x_12 = lean_box_usize(x_2); +x_13 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__2___boxed), 7, 5); +lean_closure_set(x_13, 0, x_9); +lean_closure_set(x_13, 1, x_12); +lean_closure_set(x_13, 2, x_3); +lean_closure_set(x_13, 3, x_10); +lean_closure_set(x_13, 4, x_4); +x_14 = l_Task_Priority_default; +x_15 = 0; +x_16 = lean_io_map_task(x_13, x_11, x_14, x_15, x_6); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_16); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_16, 0); +x_19 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__3), 2, 1); +lean_closure_set(x_19, 0, x_8); +x_20 = 1; +x_21 = lean_task_map(x_19, x_18, x_14, x_20); +lean_ctor_set(x_16, 0, x_21); +return x_16; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_16, 0); +x_23 = lean_ctor_get(x_16, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_16); +x_24 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__3), 2, 1); +lean_closure_set(x_24, 0, x_8); +x_25 = 1; +x_26 = lean_task_map(x_24, x_22, x_14, x_25); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_23); +return x_27; +} +} +else +{ +uint8_t x_28; +lean_dec(x_8); +x_28 = !lean_is_exclusive(x_16); +if (x_28 == 0) +{ +return x_16; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_16, 0); +x_30 = lean_ctor_get(x_16, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_16); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +return x_31; +} +} +} +else +{ +uint8_t x_32; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_32 = !lean_is_exclusive(x_5); +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; +x_33 = lean_task_pure(x_5); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_6); +return x_34; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_35 = lean_ctor_get(x_5, 0); +x_36 = lean_ctor_get(x_5, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_5); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +x_38 = lean_task_pure(x_37); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_6); +return x_39; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__5(lean_object* x_1, lean_object* x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_ctor_get(x_1, 0); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_box_usize(x_3); +x_12 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__4___boxed), 6, 4); +lean_closure_set(x_12, 0, x_2); +lean_closure_set(x_12, 1, x_11); +lean_closure_set(x_12, 2, x_9); +lean_closure_set(x_12, 3, x_4); +x_13 = l_Task_Priority_default; +x_14 = 0; +x_15 = lean_io_bind_task(x_10, x_12, x_13, x_14, x_6); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_15); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; +x_17 = lean_ctor_get(x_15, 0); +x_18 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__3), 2, 1); +lean_closure_set(x_18, 0, x_8); +x_19 = 1; +x_20 = lean_task_map(x_18, x_17, x_13, x_19); +lean_ctor_set(x_15, 0, x_20); +return x_15; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; +x_21 = lean_ctor_get(x_15, 0); +x_22 = lean_ctor_get(x_15, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_15); +x_23 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__3), 2, 1); +lean_closure_set(x_23, 0, x_8); +x_24 = 1; +x_25 = lean_task_map(x_23, x_21, x_13, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_22); +return x_26; +} +} +else +{ +uint8_t x_27; +lean_dec(x_8); +x_27 = !lean_is_exclusive(x_15); +if (x_27 == 0) +{ +return x_15; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_15, 0); +x_29 = lean_ctor_get(x_15, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_15); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +return x_30; +} +} +} +else +{ +uint8_t x_31; +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_31 = !lean_is_exclusive(x_5); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; +x_32 = lean_task_pure(x_5); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_6); +return x_33; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_34 = lean_ctor_get(x_5, 0); +x_35 = lean_ctor_get(x_5, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_5); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +x_37 = lean_task_pure(x_36); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_6); +return x_38; +} +} +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___lambda__6___closed__1() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = 0; +x_2 = l_Lake_OrdHashSet_empty___at_Lake_OrdModuleSet_empty___spec__1; +x_3 = lean_box(x_1); +x_4 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_4, 0, x_3); +lean_ctor_set(x_4, 1, x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__6(size_t x_1, lean_object* x_2, lean_object* x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_228; lean_object* x_229; +x_12 = l_Lake_BuildJob_mixArray___rarg(x_5); +x_208 = lean_array_get_size(x_9); +x_228 = l_Lake_buildImportsAndDeps___lambda__6___closed__1; +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_229 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8(x_2, x_3, x_4, x_1, x_228, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; lean_object* x_231; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +x_231 = lean_ctor_get(x_230, 0); +lean_inc(x_231); +if (lean_obj_tag(x_231) == 0) +{ +lean_object* x_232; lean_object* x_233; uint8_t x_234; +x_232 = lean_ctor_get(x_231, 0); +lean_inc(x_232); +x_233 = lean_ctor_get(x_232, 0); +lean_inc(x_233); +x_234 = lean_unbox(x_233); +lean_dec(x_233); +if (x_234 == 0) +{ +lean_object* x_235; uint8_t x_236; +x_235 = lean_ctor_get(x_229, 1); +lean_inc(x_235); +lean_dec(x_229); +x_236 = !lean_is_exclusive(x_230); +if (x_236 == 0) +{ +lean_object* x_237; uint8_t x_238; +x_237 = lean_ctor_get(x_230, 0); +lean_dec(x_237); +x_238 = !lean_is_exclusive(x_231); +if (x_238 == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; +x_239 = lean_ctor_get(x_231, 0); +lean_dec(x_239); +x_240 = lean_ctor_get(x_232, 1); +lean_inc(x_240); +lean_dec(x_232); +x_241 = lean_ctor_get(x_240, 1); +lean_inc(x_241); +lean_dec(x_240); +lean_ctor_set(x_231, 0, x_241); +x_209 = x_230; +x_210 = x_235; +goto block_227; +} +else +{ +lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; +x_242 = lean_ctor_get(x_231, 1); +lean_inc(x_242); +lean_dec(x_231); +x_243 = lean_ctor_get(x_232, 1); +lean_inc(x_243); +lean_dec(x_232); +x_244 = lean_ctor_get(x_243, 1); +lean_inc(x_244); +lean_dec(x_243); +x_245 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_245, 0, x_244); +lean_ctor_set(x_245, 1, x_242); +lean_ctor_set(x_230, 0, x_245); +x_209 = x_230; +x_210 = x_235; +goto block_227; +} +} +else +{ +lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; +x_246 = lean_ctor_get(x_230, 1); +lean_inc(x_246); +lean_dec(x_230); +x_247 = lean_ctor_get(x_231, 1); +lean_inc(x_247); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + lean_ctor_release(x_231, 1); + x_248 = x_231; +} else { + lean_dec_ref(x_231); + x_248 = lean_box(0); +} +x_249 = lean_ctor_get(x_232, 1); +lean_inc(x_249); +lean_dec(x_232); +x_250 = lean_ctor_get(x_249, 1); +lean_inc(x_250); +lean_dec(x_249); +if (lean_is_scalar(x_248)) { + x_251 = lean_alloc_ctor(0, 2, 0); +} else { + x_251 = x_248; +} +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_247); +x_252 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_246); +x_209 = x_252; +x_210 = x_235; +goto block_227; +} +} +else +{ +lean_object* x_253; uint8_t x_254; +lean_dec(x_232); +x_253 = lean_ctor_get(x_229, 1); +lean_inc(x_253); +lean_dec(x_229); +x_254 = !lean_is_exclusive(x_230); +if (x_254 == 0) +{ +lean_object* x_255; uint8_t x_256; +x_255 = lean_ctor_get(x_230, 0); +lean_dec(x_255); +x_256 = !lean_is_exclusive(x_231); +if (x_256 == 0) +{ +lean_object* x_257; lean_object* x_258; lean_object* x_259; +x_257 = lean_ctor_get(x_231, 1); +x_258 = lean_ctor_get(x_231, 0); +lean_dec(x_258); +x_259 = lean_array_get_size(x_257); +lean_ctor_set_tag(x_231, 1); +lean_ctor_set(x_231, 0, x_259); +x_209 = x_230; +x_210 = x_253; +goto block_227; +} +else +{ +lean_object* x_260; lean_object* x_261; lean_object* x_262; +x_260 = lean_ctor_get(x_231, 1); +lean_inc(x_260); +lean_dec(x_231); +x_261 = lean_array_get_size(x_260); +x_262 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_262, 0, x_261); +lean_ctor_set(x_262, 1, x_260); +lean_ctor_set(x_230, 0, x_262); +x_209 = x_230; +x_210 = x_253; +goto block_227; +} +} +else +{ +lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +x_263 = lean_ctor_get(x_230, 1); +lean_inc(x_263); +lean_dec(x_230); +x_264 = lean_ctor_get(x_231, 1); +lean_inc(x_264); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + lean_ctor_release(x_231, 1); + x_265 = x_231; +} else { + lean_dec_ref(x_231); + x_265 = lean_box(0); +} +x_266 = lean_array_get_size(x_264); +if (lean_is_scalar(x_265)) { + x_267 = lean_alloc_ctor(1, 2, 0); +} else { + x_267 = x_265; + lean_ctor_set_tag(x_267, 1); +} +lean_ctor_set(x_267, 0, x_266); +lean_ctor_set(x_267, 1, x_264); +x_268 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_268, 0, x_267); +lean_ctor_set(x_268, 1, x_263); +x_209 = x_268; +x_210 = x_253; +goto block_227; +} +} +} +else +{ +lean_object* x_269; uint8_t x_270; +x_269 = lean_ctor_get(x_229, 1); +lean_inc(x_269); +lean_dec(x_229); +x_270 = !lean_is_exclusive(x_230); +if (x_270 == 0) +{ +lean_object* x_271; uint8_t x_272; +x_271 = lean_ctor_get(x_230, 0); +lean_dec(x_271); +x_272 = !lean_is_exclusive(x_231); +if (x_272 == 0) +{ +x_209 = x_230; +x_210 = x_269; +goto block_227; +} +else +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; +x_273 = lean_ctor_get(x_231, 0); +x_274 = lean_ctor_get(x_231, 1); +lean_inc(x_274); +lean_inc(x_273); +lean_dec(x_231); +x_275 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_275, 0, x_273); +lean_ctor_set(x_275, 1, x_274); +lean_ctor_set(x_230, 0, x_275); +x_209 = x_230; +x_210 = x_269; +goto block_227; +} +} +else +{ +lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; +x_276 = lean_ctor_get(x_230, 1); +lean_inc(x_276); +lean_dec(x_230); +x_277 = lean_ctor_get(x_231, 0); +lean_inc(x_277); +x_278 = lean_ctor_get(x_231, 1); +lean_inc(x_278); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + lean_ctor_release(x_231, 1); + x_279 = x_231; +} else { + lean_dec_ref(x_231); + x_279 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_280 = lean_alloc_ctor(1, 2, 0); +} else { + x_280 = x_279; +} +lean_ctor_set(x_280, 0, x_277); +lean_ctor_set(x_280, 1, x_278); +x_281 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_281, 0, x_280); +lean_ctor_set(x_281, 1, x_276); +x_209 = x_281; +x_210 = x_269; +goto block_227; +} +} +} +else +{ +uint8_t x_282; +lean_dec(x_208); +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_282 = !lean_is_exclusive(x_229); +if (x_282 == 0) +{ +return x_229; +} +else +{ +lean_object* x_283; lean_object* x_284; lean_object* x_285; +x_283 = lean_ctor_get(x_229, 0); +x_284 = lean_ctor_get(x_229, 1); +lean_inc(x_284); +lean_inc(x_283); +lean_dec(x_229); +x_285 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_285, 0, x_283); +lean_ctor_set(x_285, 1, x_284); +return x_285; +} +} +block_207: +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_13, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_162; lean_object* x_163; uint8_t x_164; lean_object* x_165; +x_16 = lean_ctor_get(x_13, 1); +lean_inc(x_16); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_17 = x_13; +} else { + lean_dec_ref(x_13); + x_17 = lean_box(0); +} +x_18 = lean_ctor_get(x_15, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_15, 1); +lean_inc(x_19); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_20 = x_15; +} else { + lean_dec_ref(x_15); + x_20 = lean_box(0); +} +x_162 = lean_array_get_size(x_18); +x_163 = lean_unsigned_to_nat(0u); +x_164 = lean_nat_dec_lt(x_163, x_162); +if (x_164 == 0) +{ +lean_object* x_186; +lean_dec(x_162); +x_186 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_165 = x_186; +goto block_185; +} +else +{ +uint8_t x_187; +x_187 = lean_nat_dec_le(x_162, x_162); +if (x_187 == 0) +{ +lean_object* x_188; +lean_dec(x_162); +x_188 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_165 = x_188; +goto block_185; +} +else +{ +size_t x_189; lean_object* x_190; lean_object* x_191; +x_189 = lean_usize_of_nat(x_162); +lean_dec(x_162); +x_190 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_191 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15(x_18, x_1, x_189, x_190); +x_165 = x_191; +goto block_185; +} +} +block_161: +{ +lean_object* x_23; +x_23 = lean_ctor_get(x_21, 0); +lean_inc(x_23); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; size_t x_29; lean_object* x_30; +x_24 = lean_ctor_get(x_21, 1); +lean_inc(x_24); +lean_dec(x_21); +x_25 = lean_ctor_get(x_23, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_23, 1); +lean_inc(x_26); +lean_dec(x_23); +x_27 = l_Lake_BuildJob_collectArray___rarg(x_25); +lean_dec(x_25); +x_28 = lean_array_get_size(x_18); +x_29 = lean_usize_of_nat(x_28); +lean_dec(x_28); +lean_inc(x_8); +x_30 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2(x_29, x_1, x_18, x_6, x_7, x_8, x_26, x_24, x_22); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +if (lean_obj_tag(x_32) == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_30, 1); +lean_inc(x_33); +lean_dec(x_30); +x_34 = !lean_is_exclusive(x_31); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_31, 1); +x_36 = lean_ctor_get(x_31, 0); +lean_dec(x_36); +x_37 = !lean_is_exclusive(x_32); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; +x_38 = lean_ctor_get(x_32, 0); +x_39 = lean_ctor_get(x_32, 1); +x_40 = l_Lake_BuildJob_collectArray___rarg(x_38); +lean_dec(x_38); +x_41 = !lean_is_exclusive(x_12); +if (x_41 == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; lean_object* x_48; +x_42 = lean_ctor_get(x_12, 0); +x_43 = lean_ctor_get(x_12, 1); +x_44 = lean_box_usize(x_1); +x_45 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__5___boxed), 6, 4); +lean_closure_set(x_45, 0, x_40); +lean_closure_set(x_45, 1, x_27); +lean_closure_set(x_45, 2, x_44); +lean_closure_set(x_45, 3, x_8); +x_46 = l_Task_Priority_default; +x_47 = 0; +x_48 = lean_io_bind_task(x_42, x_45, x_46, x_47, x_33); +if (lean_obj_tag(x_48) == 0) +{ +uint8_t x_49; +x_49 = !lean_is_exclusive(x_48); +if (x_49 == 0) +{ +lean_object* x_50; +x_50 = lean_ctor_get(x_48, 0); +lean_ctor_set(x_12, 0, x_50); +lean_ctor_set(x_32, 0, x_12); +lean_ctor_set(x_48, 0, x_31); +return x_48; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_48, 0); +x_52 = lean_ctor_get(x_48, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_48); +lean_ctor_set(x_12, 0, x_51); +lean_ctor_set(x_32, 0, x_12); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_31); +lean_ctor_set(x_53, 1, x_52); +return x_53; +} +} +else +{ +uint8_t x_54; +lean_free_object(x_12); +lean_dec(x_43); +lean_free_object(x_32); +lean_dec(x_39); +lean_free_object(x_31); +lean_dec(x_35); +x_54 = !lean_is_exclusive(x_48); +if (x_54 == 0) +{ +return x_48; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_48, 0); +x_56 = lean_ctor_get(x_48, 1); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_48); +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set(x_57, 1, x_56); +return x_57; +} +} +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; +x_58 = lean_ctor_get(x_12, 0); +x_59 = lean_ctor_get(x_12, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_12); +x_60 = lean_box_usize(x_1); +x_61 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__5___boxed), 6, 4); +lean_closure_set(x_61, 0, x_40); +lean_closure_set(x_61, 1, x_27); +lean_closure_set(x_61, 2, x_60); +lean_closure_set(x_61, 3, x_8); +x_62 = l_Task_Priority_default; +x_63 = 0; +x_64 = lean_io_bind_task(x_58, x_61, x_62, x_63, x_33); +if (lean_obj_tag(x_64) == 0) +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_65 = lean_ctor_get(x_64, 0); +lean_inc(x_65); +x_66 = lean_ctor_get(x_64, 1); +lean_inc(x_66); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_67 = x_64; +} else { + lean_dec_ref(x_64); + x_67 = lean_box(0); +} +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_65); +lean_ctor_set(x_68, 1, x_59); +lean_ctor_set(x_32, 0, x_68); +if (lean_is_scalar(x_67)) { + x_69 = lean_alloc_ctor(0, 2, 0); +} else { + x_69 = x_67; +} +lean_ctor_set(x_69, 0, x_31); +lean_ctor_set(x_69, 1, x_66); +return x_69; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +lean_dec(x_59); +lean_free_object(x_32); +lean_dec(x_39); +lean_free_object(x_31); +lean_dec(x_35); +x_70 = lean_ctor_get(x_64, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_64, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_72 = x_64; +} else { + lean_dec_ref(x_64); + x_72 = lean_box(0); +} +if (lean_is_scalar(x_72)) { + x_73 = lean_alloc_ctor(1, 2, 0); +} else { + x_73 = x_72; +} +lean_ctor_set(x_73, 0, x_70); +lean_ctor_set(x_73, 1, x_71); +return x_73; +} +} +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; +x_74 = lean_ctor_get(x_32, 0); +x_75 = lean_ctor_get(x_32, 1); +lean_inc(x_75); +lean_inc(x_74); +lean_dec(x_32); +x_76 = l_Lake_BuildJob_collectArray___rarg(x_74); +lean_dec(x_74); +x_77 = lean_ctor_get(x_12, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_12, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_79 = x_12; +} else { + lean_dec_ref(x_12); + x_79 = lean_box(0); +} +x_80 = lean_box_usize(x_1); +x_81 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__5___boxed), 6, 4); +lean_closure_set(x_81, 0, x_76); +lean_closure_set(x_81, 1, x_27); +lean_closure_set(x_81, 2, x_80); +lean_closure_set(x_81, 3, x_8); +x_82 = l_Task_Priority_default; +x_83 = 0; +x_84 = lean_io_bind_task(x_77, x_81, x_82, x_83, x_33); +if (lean_obj_tag(x_84) == 0) +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_85 = lean_ctor_get(x_84, 0); +lean_inc(x_85); +x_86 = lean_ctor_get(x_84, 1); +lean_inc(x_86); +if (lean_is_exclusive(x_84)) { + lean_ctor_release(x_84, 0); + lean_ctor_release(x_84, 1); + x_87 = x_84; +} else { + lean_dec_ref(x_84); + x_87 = lean_box(0); +} +if (lean_is_scalar(x_79)) { + x_88 = lean_alloc_ctor(0, 2, 0); +} else { + x_88 = x_79; +} +lean_ctor_set(x_88, 0, x_85); +lean_ctor_set(x_88, 1, x_78); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_75); +lean_ctor_set(x_31, 0, x_89); +if (lean_is_scalar(x_87)) { + x_90 = lean_alloc_ctor(0, 2, 0); +} else { + x_90 = x_87; +} +lean_ctor_set(x_90, 0, x_31); +lean_ctor_set(x_90, 1, x_86); +return x_90; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_75); +lean_free_object(x_31); +lean_dec(x_35); +x_91 = lean_ctor_get(x_84, 0); +lean_inc(x_91); +x_92 = lean_ctor_get(x_84, 1); +lean_inc(x_92); +if (lean_is_exclusive(x_84)) { + lean_ctor_release(x_84, 0); + lean_ctor_release(x_84, 1); + x_93 = x_84; +} else { + lean_dec_ref(x_84); + x_93 = lean_box(0); +} +if (lean_is_scalar(x_93)) { + x_94 = lean_alloc_ctor(1, 2, 0); +} else { + x_94 = x_93; +} +lean_ctor_set(x_94, 0, x_91); +lean_ctor_set(x_94, 1, x_92); +return x_94; +} +} +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; +x_95 = lean_ctor_get(x_31, 1); +lean_inc(x_95); +lean_dec(x_31); +x_96 = lean_ctor_get(x_32, 0); +lean_inc(x_96); +x_97 = lean_ctor_get(x_32, 1); +lean_inc(x_97); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_98 = x_32; +} else { + lean_dec_ref(x_32); + x_98 = lean_box(0); +} +x_99 = l_Lake_BuildJob_collectArray___rarg(x_96); +lean_dec(x_96); +x_100 = lean_ctor_get(x_12, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_12, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_102 = x_12; +} else { + lean_dec_ref(x_12); + x_102 = lean_box(0); +} +x_103 = lean_box_usize(x_1); +x_104 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__5___boxed), 6, 4); +lean_closure_set(x_104, 0, x_99); +lean_closure_set(x_104, 1, x_27); +lean_closure_set(x_104, 2, x_103); +lean_closure_set(x_104, 3, x_8); +x_105 = l_Task_Priority_default; +x_106 = 0; +x_107 = lean_io_bind_task(x_100, x_104, x_105, x_106, x_33); +if (lean_obj_tag(x_107) == 0) +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; +x_108 = lean_ctor_get(x_107, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_107, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_107)) { + lean_ctor_release(x_107, 0); + lean_ctor_release(x_107, 1); + x_110 = x_107; +} else { + lean_dec_ref(x_107); + x_110 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_111 = lean_alloc_ctor(0, 2, 0); +} else { + x_111 = x_102; +} +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_101); +if (lean_is_scalar(x_98)) { + x_112 = lean_alloc_ctor(0, 2, 0); +} else { + x_112 = x_98; +} +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_97); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_95); +if (lean_is_scalar(x_110)) { + x_114 = lean_alloc_ctor(0, 2, 0); +} else { + x_114 = x_110; +} +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_114, 1, x_109); +return x_114; +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; +lean_dec(x_102); +lean_dec(x_101); +lean_dec(x_98); +lean_dec(x_97); +lean_dec(x_95); +x_115 = lean_ctor_get(x_107, 0); +lean_inc(x_115); +x_116 = lean_ctor_get(x_107, 1); +lean_inc(x_116); +if (lean_is_exclusive(x_107)) { + lean_ctor_release(x_107, 0); + lean_ctor_release(x_107, 1); + x_117 = x_107; +} else { + lean_dec_ref(x_107); + x_117 = lean_box(0); +} +if (lean_is_scalar(x_117)) { + x_118 = lean_alloc_ctor(1, 2, 0); +} else { + x_118 = x_117; +} +lean_ctor_set(x_118, 0, x_115); +lean_ctor_set(x_118, 1, x_116); +return x_118; +} +} +} +else +{ +uint8_t x_119; +lean_dec(x_27); +lean_dec(x_12); +lean_dec(x_8); +x_119 = !lean_is_exclusive(x_30); +if (x_119 == 0) +{ +lean_object* x_120; uint8_t x_121; +x_120 = lean_ctor_get(x_30, 0); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_31); +if (x_121 == 0) +{ +lean_object* x_122; uint8_t x_123; +x_122 = lean_ctor_get(x_31, 0); +lean_dec(x_122); +x_123 = !lean_is_exclusive(x_32); +if (x_123 == 0) +{ +return x_30; +} +else +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; +x_124 = lean_ctor_get(x_32, 0); +x_125 = lean_ctor_get(x_32, 1); +lean_inc(x_125); +lean_inc(x_124); +lean_dec(x_32); +x_126 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_126, 0, x_124); +lean_ctor_set(x_126, 1, x_125); +lean_ctor_set(x_31, 0, x_126); +return x_30; +} +} +else +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_127 = lean_ctor_get(x_31, 1); +lean_inc(x_127); +lean_dec(x_31); +x_128 = lean_ctor_get(x_32, 0); +lean_inc(x_128); +x_129 = lean_ctor_get(x_32, 1); +lean_inc(x_129); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_130 = x_32; +} else { + lean_dec_ref(x_32); + x_130 = lean_box(0); +} +if (lean_is_scalar(x_130)) { + x_131 = lean_alloc_ctor(1, 2, 0); +} else { + x_131 = x_130; +} +lean_ctor_set(x_131, 0, x_128); +lean_ctor_set(x_131, 1, x_129); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_127); +lean_ctor_set(x_30, 0, x_132); +return x_30; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +x_133 = lean_ctor_get(x_30, 1); +lean_inc(x_133); +lean_dec(x_30); +x_134 = lean_ctor_get(x_31, 1); +lean_inc(x_134); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_135 = x_31; +} else { + lean_dec_ref(x_31); + x_135 = lean_box(0); +} +x_136 = lean_ctor_get(x_32, 0); +lean_inc(x_136); +x_137 = lean_ctor_get(x_32, 1); +lean_inc(x_137); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_138 = x_32; +} else { + lean_dec_ref(x_32); + x_138 = lean_box(0); +} +if (lean_is_scalar(x_138)) { + x_139 = lean_alloc_ctor(1, 2, 0); +} else { + x_139 = x_138; +} +lean_ctor_set(x_139, 0, x_136); +lean_ctor_set(x_139, 1, x_137); +if (lean_is_scalar(x_135)) { + x_140 = lean_alloc_ctor(0, 2, 0); +} else { + x_140 = x_135; +} +lean_ctor_set(x_140, 0, x_139); +lean_ctor_set(x_140, 1, x_134); +x_141 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_141, 0, x_140); +lean_ctor_set(x_141, 1, x_133); +return x_141; +} +} +} +else +{ +uint8_t x_142; +lean_dec(x_27); +lean_dec(x_12); +lean_dec(x_8); +x_142 = !lean_is_exclusive(x_30); +if (x_142 == 0) +{ +return x_30; +} +else +{ +lean_object* x_143; lean_object* x_144; lean_object* x_145; +x_143 = lean_ctor_get(x_30, 0); +x_144 = lean_ctor_get(x_30, 1); +lean_inc(x_144); +lean_inc(x_143); +lean_dec(x_30); +x_145 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_145, 0, x_143); +lean_ctor_set(x_145, 1, x_144); +return x_145; +} +} +} +else +{ +uint8_t x_146; +lean_dec(x_18); +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_146 = !lean_is_exclusive(x_21); +if (x_146 == 0) +{ +lean_object* x_147; uint8_t x_148; +x_147 = lean_ctor_get(x_21, 0); +lean_dec(x_147); +x_148 = !lean_is_exclusive(x_23); +if (x_148 == 0) +{ +lean_object* x_149; +x_149 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_149, 0, x_21); +lean_ctor_set(x_149, 1, x_22); +return x_149; +} +else +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; +x_150 = lean_ctor_get(x_23, 0); +x_151 = lean_ctor_get(x_23, 1); +lean_inc(x_151); +lean_inc(x_150); +lean_dec(x_23); +x_152 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set(x_152, 1, x_151); +lean_ctor_set(x_21, 0, x_152); +x_153 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_153, 0, x_21); +lean_ctor_set(x_153, 1, x_22); +return x_153; +} +} +else +{ +lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_154 = lean_ctor_get(x_21, 1); +lean_inc(x_154); +lean_dec(x_21); +x_155 = lean_ctor_get(x_23, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_23, 1); +lean_inc(x_156); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + lean_ctor_release(x_23, 1); + x_157 = x_23; +} else { + lean_dec_ref(x_23); + x_157 = lean_box(0); +} +if (lean_is_scalar(x_157)) { + x_158 = lean_alloc_ctor(1, 2, 0); +} else { + x_158 = x_157; +} +lean_ctor_set(x_158, 0, x_155); +lean_ctor_set(x_158, 1, x_156); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_154); +x_160 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_22); +return x_160; +} +} +} +block_185: +{ +lean_object* x_166; lean_object* x_167; uint8_t x_168; +x_166 = lean_ctor_get(x_165, 1); +lean_inc(x_166); +lean_dec(x_165); +x_167 = lean_array_get_size(x_166); +x_168 = lean_nat_dec_lt(x_163, x_167); +if (x_168 == 0) +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; +lean_dec(x_167); +lean_dec(x_166); +x_169 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1; +if (lean_is_scalar(x_20)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_20; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_19); +if (lean_is_scalar(x_17)) { + x_171 = lean_alloc_ctor(0, 2, 0); +} else { + x_171 = x_17; +} +lean_ctor_set(x_171, 0, x_170); +lean_ctor_set(x_171, 1, x_16); +x_21 = x_171; +x_22 = x_14; +goto block_161; +} +else +{ +uint8_t x_172; +x_172 = lean_nat_dec_le(x_167, x_167); +if (x_172 == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; +lean_dec(x_167); +lean_dec(x_166); +x_173 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1; +if (lean_is_scalar(x_20)) { + x_174 = lean_alloc_ctor(0, 2, 0); +} else { + x_174 = x_20; +} +lean_ctor_set(x_174, 0, x_173); +lean_ctor_set(x_174, 1, x_19); +if (lean_is_scalar(x_17)) { + x_175 = lean_alloc_ctor(0, 2, 0); +} else { + x_175 = x_17; +} +lean_ctor_set(x_175, 0, x_174); +lean_ctor_set(x_175, 1, x_16); +x_21 = x_175; +x_22 = x_14; +goto block_161; +} +else +{ +size_t x_176; lean_object* x_177; lean_object* x_178; +lean_dec(x_20); +lean_dec(x_17); +x_176 = lean_usize_of_nat(x_167); +lean_dec(x_167); +x_177 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1; +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_178 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7(x_1, x_166, x_1, x_176, x_177, x_6, x_7, x_8, x_19, x_16, x_14); +lean_dec(x_166); +if (lean_obj_tag(x_178) == 0) +{ +lean_object* x_179; lean_object* x_180; +x_179 = lean_ctor_get(x_178, 0); +lean_inc(x_179); +x_180 = lean_ctor_get(x_178, 1); +lean_inc(x_180); +lean_dec(x_178); +x_21 = x_179; +x_22 = x_180; +goto block_161; +} +else +{ +uint8_t x_181; +lean_dec(x_18); +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_181 = !lean_is_exclusive(x_178); +if (x_181 == 0) +{ +return x_178; +} +else +{ +lean_object* x_182; lean_object* x_183; lean_object* x_184; +x_182 = lean_ctor_get(x_178, 0); +x_183 = lean_ctor_get(x_178, 1); +lean_inc(x_183); +lean_inc(x_182); +lean_dec(x_178); +x_184 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_184, 0, x_182); +lean_ctor_set(x_184, 1, x_183); +return x_184; +} +} +} +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_192 = !lean_is_exclusive(x_13); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_13, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_15); +if (x_194 == 0) +{ +lean_object* x_195; +x_195 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_195, 0, x_13); +lean_ctor_set(x_195, 1, x_14); +return x_195; +} +else +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; +x_196 = lean_ctor_get(x_15, 0); +x_197 = lean_ctor_get(x_15, 1); +lean_inc(x_197); +lean_inc(x_196); +lean_dec(x_15); +x_198 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_198, 0, x_196); +lean_ctor_set(x_198, 1, x_197); +lean_ctor_set(x_13, 0, x_198); +x_199 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_199, 0, x_13); +lean_ctor_set(x_199, 1, x_14); +return x_199; +} +} +else +{ +lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; +x_200 = lean_ctor_get(x_13, 1); +lean_inc(x_200); +lean_dec(x_13); +x_201 = lean_ctor_get(x_15, 0); +lean_inc(x_201); +x_202 = lean_ctor_get(x_15, 1); +lean_inc(x_202); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_203 = x_15; +} else { + lean_dec_ref(x_15); + x_203 = lean_box(0); +} +if (lean_is_scalar(x_203)) { + x_204 = lean_alloc_ctor(1, 2, 0); +} else { + x_204 = x_203; +} +lean_ctor_set(x_204, 0, x_201); +lean_ctor_set(x_204, 1, x_202); +x_205 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_205, 0, x_204); +lean_ctor_set(x_205, 1, x_200); +x_206 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_206, 0, x_205); +lean_ctor_set(x_206, 1, x_14); +return x_206; +} +} +} +block_227: +{ +lean_object* x_211; +x_211 = lean_ctor_get(x_209, 0); +lean_inc(x_211); +if (lean_obj_tag(x_211) == 0) +{ +uint8_t x_212; +lean_dec(x_208); +x_212 = !lean_is_exclusive(x_209); +if (x_212 == 0) +{ +lean_object* x_213; +x_213 = lean_ctor_get(x_209, 0); +lean_dec(x_213); +x_13 = x_209; +x_14 = x_210; +goto block_207; +} +else +{ +lean_object* x_214; lean_object* x_215; +x_214 = lean_ctor_get(x_209, 1); +lean_inc(x_214); +lean_dec(x_209); +x_215 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_215, 0, x_211); +lean_ctor_set(x_215, 1, x_214); +x_13 = x_215; +x_14 = x_210; +goto block_207; +} +} +else +{ +uint8_t x_216; +x_216 = !lean_is_exclusive(x_209); +if (x_216 == 0) +{ +lean_object* x_217; uint8_t x_218; +x_217 = lean_ctor_get(x_209, 0); +lean_dec(x_217); +x_218 = !lean_is_exclusive(x_211); +if (x_218 == 0) +{ +lean_object* x_219; +x_219 = lean_ctor_get(x_211, 0); +lean_dec(x_219); +lean_ctor_set(x_211, 0, x_208); +x_13 = x_209; +x_14 = x_210; +goto block_207; +} +else +{ +lean_object* x_220; lean_object* x_221; +x_220 = lean_ctor_get(x_211, 1); +lean_inc(x_220); +lean_dec(x_211); +x_221 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_221, 0, x_208); +lean_ctor_set(x_221, 1, x_220); +lean_ctor_set(x_209, 0, x_221); +x_13 = x_209; +x_14 = x_210; +goto block_207; +} +} +else +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_222 = lean_ctor_get(x_209, 1); +lean_inc(x_222); +lean_dec(x_209); +x_223 = lean_ctor_get(x_211, 1); +lean_inc(x_223); +if (lean_is_exclusive(x_211)) { + lean_ctor_release(x_211, 0); + lean_ctor_release(x_211, 1); + x_224 = x_211; +} else { + lean_dec_ref(x_211); + x_224 = lean_box(0); +} +if (lean_is_scalar(x_224)) { + x_225 = lean_alloc_ctor(1, 2, 0); +} else { + x_225 = x_224; +} +lean_ctor_set(x_225, 0, x_208); +lean_ctor_set(x_225, 1, x_223); +x_226 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_222); +x_13 = x_226; +x_14 = x_210; +goto block_207; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__7(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__8(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__9(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_4); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_5); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__10(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_dec(x_3); +x_4 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1; +lean_ctor_set(x_1, 0, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1; +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___lambda__11___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__10), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___lambda__11___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_buildImportsAndDeps___lambda__11___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__11(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Lake_buildImportsAndDeps___lambda__11___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Lake_buildImportsAndDeps___lambda__11___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___lambda__12___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("extraDep", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___lambda__12___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_buildImportsAndDeps___lambda__12___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___lambda__12___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__11), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__12(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_8 = l_Lake_buildImportsAndDeps___lambda__12___closed__2; +x_9 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +x_10 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_10, 0, x_9); +lean_closure_set(x_10, 1, lean_box(0)); +x_11 = l_Lake_buildImportsAndDeps___lambda__12___closed__3; +x_12 = l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11___rarg(x_10, x_11, x_2, x_3, x_4, x_5, x_6, x_7); +return x_12; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("imports (", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(")", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__9___boxed), 5, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_buildImportsAndDeps___closed__3; +x_2 = lean_alloc_closure((void*)(l_Lake_EquipT_lift___rarg___boxed), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__8___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_buildImportsAndDeps___closed__5; +x_2 = l_Lake_buildImportsAndDeps___closed__4; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg), 8, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__7___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_buildImportsAndDeps___closed__7; +x_2 = l_Lake_buildImportsAndDeps___closed__6; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg), 8, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__12), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_buildImportsAndDeps___closed__8; +x_2 = l_Lake_buildImportsAndDeps___closed__9; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_buildImportsAndDeps___boxed__const__1() { +_start: +{ +size_t x_1; lean_object* x_2; +x_1 = 0; +x_2 = lean_box_usize(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_9 = l_Lake_buildImportsAndDeps___closed__1; +x_10 = lean_string_append(x_9, x_1); +x_11 = l_Lake_buildImportsAndDeps___closed__2; +x_12 = lean_string_append(x_10, x_11); +x_13 = l_Array_isEmpty___rarg(x_2); +if (x_13 == 0) +{ +lean_object* x_14; size_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_14 = lean_array_get_size(x_2); +x_15 = lean_usize_of_nat(x_14); +lean_dec(x_14); +x_16 = lean_box_usize(x_15); +x_17 = l_Lake_buildImportsAndDeps___boxed__const__1; +lean_inc(x_2); +x_18 = lean_alloc_closure((void*)(l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___boxed), 9, 3); +lean_closure_set(x_18, 0, x_16); +lean_closure_set(x_18, 1, x_17); +lean_closure_set(x_18, 2, x_2); +x_19 = l_Lake_buildImportsAndDeps___boxed__const__1; +x_20 = lean_box_usize(x_15); +x_21 = lean_alloc_closure((void*)(l_Lake_buildImportsAndDeps___lambda__6___boxed), 11, 4); +lean_closure_set(x_21, 0, x_19); +lean_closure_set(x_21, 1, x_1); +lean_closure_set(x_21, 2, x_2); +lean_closure_set(x_21, 3, x_20); +x_22 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 2); +lean_closure_set(x_22, 0, x_18); +lean_closure_set(x_22, 1, x_21); +x_23 = l_Lake_withRegisterJob___rarg(x_12, x_22, x_3, x_4, x_5, x_6, x_7, x_8); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; +lean_dec(x_2); +lean_dec(x_1); +x_24 = l_Lake_buildImportsAndDeps___closed__10; +x_25 = l_Lake_withRegisterJob___rarg(x_12, x_24, x_3, x_4, x_5, x_6, x_7, x_8); +return x_25; +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; size_t x_11; lean_object* x_12; +x_10 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1(x_10, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_buildImportsAndDeps___spec__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_fold___at_Lake_buildImportsAndDeps___spec__6(x_1, x_2, x_3); +lean_dec(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; size_t x_14; lean_object* x_15; +x_12 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_13 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_14 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_15 = l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7(x_12, x_2, x_13, x_14, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +lean_dec(x_1); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_buildImportsAndDeps___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +size_t x_8; lean_object* x_9; +x_8 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_9 = l_Lake_buildImportsAndDeps___lambda__2(x_1, x_8, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +size_t x_7; lean_object* x_8; +x_7 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_8 = l_Lake_buildImportsAndDeps___lambda__4(x_1, x_7, x_3, x_4, x_5, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +size_t x_7; lean_object* x_8; +x_7 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_8 = l_Lake_buildImportsAndDeps___lambda__5(x_1, x_2, x_7, x_4, x_5, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Lake_buildImportsAndDeps___lambda__6(x_12, x_2, x_3, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__7___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_buildImportsAndDeps___lambda__7(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__8___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_buildImportsAndDeps___lambda__8(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildImportsAndDeps___lambda__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_buildImportsAndDeps___lambda__9(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_2); +lean_dec(x_1); +return x_6; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Module(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Imports(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Module(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__1 = _init_l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__1(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__1); +l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__2 = _init_l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__2(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_buildImportsAndDeps___spec__1___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__1 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__1(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__2 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__2(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__3 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__3(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__3); +l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__4 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__4(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__4); +l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5 = _init_l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_buildImportsAndDeps___spec__2___closed__5); +l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1 = _init_l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_buildImportsAndDeps___spec__7___closed__1); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__1); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__2); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__3); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__4 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__4(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__4); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__5 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__5(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__5); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__6 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__6(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__6); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__7 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__7(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__7); +l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__8 = _init_l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__8(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_buildImportsAndDeps___spec__8___closed__8); +l_Lake_buildImportsAndDeps___lambda__2___closed__1 = _init_l_Lake_buildImportsAndDeps___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___lambda__2___closed__1); +l_Lake_buildImportsAndDeps___lambda__6___closed__1 = _init_l_Lake_buildImportsAndDeps___lambda__6___closed__1(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___lambda__6___closed__1); +l_Lake_buildImportsAndDeps___lambda__11___closed__1 = _init_l_Lake_buildImportsAndDeps___lambda__11___closed__1(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___lambda__11___closed__1); +l_Lake_buildImportsAndDeps___lambda__11___closed__2 = _init_l_Lake_buildImportsAndDeps___lambda__11___closed__2(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___lambda__11___closed__2); +l_Lake_buildImportsAndDeps___lambda__12___closed__1 = _init_l_Lake_buildImportsAndDeps___lambda__12___closed__1(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___lambda__12___closed__1); +l_Lake_buildImportsAndDeps___lambda__12___closed__2 = _init_l_Lake_buildImportsAndDeps___lambda__12___closed__2(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___lambda__12___closed__2); +l_Lake_buildImportsAndDeps___lambda__12___closed__3 = _init_l_Lake_buildImportsAndDeps___lambda__12___closed__3(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___lambda__12___closed__3); +l_Lake_buildImportsAndDeps___closed__1 = _init_l_Lake_buildImportsAndDeps___closed__1(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__1); +l_Lake_buildImportsAndDeps___closed__2 = _init_l_Lake_buildImportsAndDeps___closed__2(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__2); +l_Lake_buildImportsAndDeps___closed__3 = _init_l_Lake_buildImportsAndDeps___closed__3(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__3); +l_Lake_buildImportsAndDeps___closed__4 = _init_l_Lake_buildImportsAndDeps___closed__4(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__4); +l_Lake_buildImportsAndDeps___closed__5 = _init_l_Lake_buildImportsAndDeps___closed__5(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__5); +l_Lake_buildImportsAndDeps___closed__6 = _init_l_Lake_buildImportsAndDeps___closed__6(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__6); +l_Lake_buildImportsAndDeps___closed__7 = _init_l_Lake_buildImportsAndDeps___closed__7(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__7); +l_Lake_buildImportsAndDeps___closed__8 = _init_l_Lake_buildImportsAndDeps___closed__8(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__8); +l_Lake_buildImportsAndDeps___closed__9 = _init_l_Lake_buildImportsAndDeps___closed__9(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__9); +l_Lake_buildImportsAndDeps___closed__10 = _init_l_Lake_buildImportsAndDeps___closed__10(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___closed__10); +l_Lake_buildImportsAndDeps___boxed__const__1 = _init_l_Lake_buildImportsAndDeps___boxed__const__1(); +lean_mark_persistent(l_Lake_buildImportsAndDeps___boxed__const__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Index.c b/stage0/stdlib/Lake/Build/Index.c new file mode 100644 index 0000000000..08e85427bd --- /dev/null +++ b/stage0/stdlib/Lake/Build/Index.c @@ -0,0 +1,4483 @@ +// Lean compiler output +// Module: Lake.Build.Index +// Imports: Init Lake.Build.Executable Lake.Build.Topological +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* l_Lake_Workspace_findModuleFacetConfig_x3f(lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_recBuildStatic___closed__2; +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +LEAN_EXPORT lean_object* l_Lake_recBuildWithIndex(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildShared___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_recBuildStatic___closed__3; +LEAN_EXPORT lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ExternLib_recComputeDynlib___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +lean_object* l_Lake_BuildInfo_key(lean_object*); +uint8_t l_Lean_RBNode_isRed___rarg(lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +static lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__2; +static lean_object* l_Lake_recBuildWithIndex___closed__7; +LEAN_EXPORT lean_object* l_Lake_ExternLib_recComputeDynlib___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_recBuildWithIndex___closed__3; +lean_object* l_Lake_buildLeanSharedLibOfStatic(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__1; +lean_object* l_List_appendTR___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_partition_loop___at_Lake_FetchM_run___spec__5(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7___closed__1; +LEAN_EXPORT lean_object* l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_RBNode_setBlack___rarg(lean_object*); +lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_recBuildShared___closed__1; +lean_object* l_Lake_withRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_ExternLib_recBuildStatic___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_partition_loop___at_Lake_FetchM_run___spec__5___boxed(lean_object*, lean_object*, lean_object*); +uint8_t l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(lean_object*, lean_object*); +lean_object* l_Lake_Workspace_findLibraryFacetConfig_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildShared(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_ExternLib_recBuildStatic___spec__1(lean_object*, lean_object*); +static lean_object* l_Lake_FetchM_run___rarg___closed__1; +LEAN_EXPORT lean_object* l_List_elem___at_Lake_FetchM_run___spec__1___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_recBuildWithIndex___closed__1; +LEAN_EXPORT lean_object* l_Lake_ExternLib_recComputeDynlib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Package_findTargetConfig_x3f(lean_object*, lean_object*); +lean_object* l_Lake_Workspace_findPackageFacetConfig_x3f(lean_object*, lean_object*); +static lean_object* l_Lake_recBuildWithIndex___closed__2; +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_insert___at_Lake_FetchM_run___spec__3(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildStatic(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkTargetFacetBuild(lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_recBuildShared___lambda__1___closed__1; +lean_object* l_List_mapTR_loop___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__2(lean_object*, lean_object*); +static lean_object* l_Lake_recBuildWithIndex___closed__6; +LEAN_EXPORT lean_object* l_Lake_FetchM_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_recComputeDynlib___closed__1; +static lean_object* l_Lake_ExternLib_recBuildStatic___closed__1; +LEAN_EXPORT uint8_t l_List_elem___at_Lake_FetchM_run___spec__1(lean_object*, lean_object*); +lean_object* l_Lake_computeDynlibOfShared(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_FetchM_run___spec__2(lean_object*, lean_object*); +static lean_object* l_Lake_recBuildWithIndex___closed__4; +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildShared___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkTargetFacetBuild___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_FetchM_run___spec__2___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6(lean_object*); +lean_object* l_List_reverse___rarg(lean_object*); +static lean_object* l_Lake_recBuildWithIndex___closed__5; +lean_object* l_String_intercalate(lean_object*, lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +uint8_t l_Lake_BuildKey_quickCmp(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_FetchM_run(lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkTargetFacetBuild___boxed(lean_object*, lean_object*); +lean_object* l_Lake_LeanExe_recBuildExe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_recComputeDynlib___closed__2; +lean_object* l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkTargetFacetBuild___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = lean_apply_6(x_1, x_3, x_4, x_5, x_6, x_7, x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_mkTargetFacetBuild(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_mkTargetFacetBuild___rarg), 8, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_mkTargetFacetBuild___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_mkTargetFacetBuild(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_ExternLib_recBuildStatic___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_9); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_10); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_10, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_11); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_11, 0); +x_18 = lean_apply_1(x_1, x_17); +lean_ctor_set(x_11, 0, x_18); +return x_9; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_11, 0); +x_20 = lean_ctor_get(x_11, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_11); +x_21 = lean_apply_1(x_1, x_19); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +lean_ctor_set(x_10, 0, x_22); +return x_9; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_23 = lean_ctor_get(x_10, 1); +lean_inc(x_23); +lean_dec(x_10); +x_24 = lean_ctor_get(x_11, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_11, 1); +lean_inc(x_25); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_26 = x_11; +} else { + lean_dec_ref(x_11); + x_26 = lean_box(0); +} +x_27 = lean_apply_1(x_1, x_24); +if (lean_is_scalar(x_26)) { + x_28 = lean_alloc_ctor(0, 2, 0); +} else { + x_28 = x_26; +} +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_25); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_23); +lean_ctor_set(x_9, 0, x_29); +return x_9; +} +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_30 = lean_ctor_get(x_9, 1); +lean_inc(x_30); +lean_dec(x_9); +x_31 = lean_ctor_get(x_10, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_32 = x_10; +} else { + lean_dec_ref(x_10); + x_32 = lean_box(0); +} +x_33 = lean_ctor_get(x_11, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_35 = x_11; +} else { + lean_dec_ref(x_11); + x_35 = lean_box(0); +} +x_36 = lean_apply_1(x_1, x_33); +if (lean_is_scalar(x_35)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_35; +} +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_34); +if (lean_is_scalar(x_32)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_32; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_31); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_30); +return x_39; +} +} +else +{ +uint8_t x_40; +lean_dec(x_1); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +lean_object* x_41; uint8_t x_42; +x_41 = lean_ctor_get(x_9, 0); +lean_dec(x_41); +x_42 = !lean_is_exclusive(x_10); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_10, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_11); +if (x_44 == 0) +{ +return x_9; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_11, 0); +x_46 = lean_ctor_get(x_11, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_11); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_10, 0, x_47); +return x_9; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_10, 1); +lean_inc(x_48); +lean_dec(x_10); +x_49 = lean_ctor_get(x_11, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_11, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_51 = x_11; +} else { + lean_dec_ref(x_11); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +lean_ctor_set(x_9, 0, x_53); +return x_9; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_54 = lean_ctor_get(x_9, 1); +lean_inc(x_54); +lean_dec(x_9); +x_55 = lean_ctor_get(x_10, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_56 = x_10; +} else { + lean_dec_ref(x_10); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_11, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_11, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_59 = x_11; +} else { + lean_dec_ref(x_11); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +if (lean_is_scalar(x_56)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_56; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_55); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_54); +return x_62; +} +} +} +else +{ +uint8_t x_63; +lean_dec(x_1); +x_63 = !lean_is_exclusive(x_9); +if (x_63 == 0) +{ +return x_9; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_9, 0); +x_65 = lean_ctor_get(x_9, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_9); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +return x_66; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_ExternLib_recBuildStatic___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_map___at_Lake_ExternLib_recBuildStatic___spec__1___rarg), 8, 0); +return x_3; +} +} +static lean_object* _init_l_Lake_ExternLib_recBuildStatic___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("static", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_recBuildStatic___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_recBuildStatic___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":static", 7); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildStatic(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_1, 2); +lean_inc(x_10); +lean_dec(x_1); +x_11 = l_Lake_ExternLib_recBuildStatic___closed__1; +x_12 = l_Lean_Name_str___override(x_9, x_11); +x_13 = 1; +lean_inc(x_12); +x_14 = l_Lean_Name_toString(x_12, x_13); +x_15 = l_Lake_ExternLib_recBuildStatic___closed__2; +x_16 = lean_string_append(x_15, x_14); +lean_dec(x_14); +x_17 = l_Lake_ExternLib_recBuildStatic___closed__3; +x_18 = lean_string_append(x_16, x_17); +x_19 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_19, 0, x_8); +lean_ctor_set(x_19, 1, x_12); +x_20 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_20, 0, x_19); +lean_closure_set(x_20, 1, lean_box(0)); +x_21 = lean_alloc_closure((void*)(l_Lake_EquipT_map___at_Lake_ExternLib_recBuildStatic___spec__1___rarg), 8, 2); +lean_closure_set(x_21, 0, x_10); +lean_closure_set(x_21, 1, x_20); +x_22 = l_Lake_withRegisterJob___rarg(x_18, x_21, x_2, x_3, x_4, x_5, x_6, x_7); +return x_22; +} +} +static lean_object* _init_l_Lake_ExternLib_recBuildShared___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildShared___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_9 = lean_ctor_get(x_1, 0); +lean_inc(x_9); +lean_dec(x_1); +x_10 = lean_ctor_get(x_9, 2); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get(x_10, 1); +lean_inc(x_11); +lean_dec(x_10); +x_12 = lean_ctor_get(x_11, 6); +lean_inc(x_12); +lean_dec(x_11); +x_13 = l_Lake_ExternLib_recBuildShared___lambda__1___closed__1; +x_14 = l_Lake_buildLeanSharedLibOfStatic(x_2, x_12, x_13, x_5, x_8); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 0); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_6); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_7); +lean_ctor_set(x_14, 0, x_18); +return x_14; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_19 = lean_ctor_get(x_14, 0); +x_20 = lean_ctor_get(x_14, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_14); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_6); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_7); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_20); +return x_23; +} +} +else +{ +uint8_t x_24; +lean_dec(x_7); +lean_dec(x_6); +x_24 = !lean_is_exclusive(x_14); +if (x_24 == 0) +{ +return x_14; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_14, 0); +x_26 = lean_ctor_get(x_14, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_14); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +} +} +static lean_object* _init_l_Lake_ExternLib_recBuildShared___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":shared", 7); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildShared(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = l_Lake_ExternLib_recBuildStatic___closed__1; +x_10 = l_Lean_Name_str___override(x_8, x_9); +x_11 = 1; +x_12 = l_Lean_Name_toString(x_10, x_11); +x_13 = l_Lake_ExternLib_recBuildStatic___closed__2; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lake_ExternLib_recBuildShared___closed__1; +x_16 = lean_string_append(x_14, x_15); +lean_inc(x_1); +x_17 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_17, 0, x_1); +x_18 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_18, 0, x_17); +lean_closure_set(x_18, 1, lean_box(0)); +x_19 = lean_alloc_closure((void*)(l_Lake_ExternLib_recBuildShared___lambda__1___boxed), 8, 1); +lean_closure_set(x_19, 0, x_1); +x_20 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg), 8, 2); +lean_closure_set(x_20, 0, x_18); +lean_closure_set(x_20, 1, x_19); +x_21 = l_Lake_withRegisterJob___rarg(x_16, x_20, x_2, x_3, x_4, x_5, x_6, x_7); +return x_21; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_recBuildShared___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_ExternLib_recBuildShared___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_4); +lean_dec(x_3); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_recComputeDynlib___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_computeDynlibOfShared(x_1, x_4, x_7); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_8, 0); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_5); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_6); +lean_ctor_set(x_8, 0, x_12); +return x_8; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_13 = lean_ctor_get(x_8, 0); +x_14 = lean_ctor_get(x_8, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_8); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_5); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_6); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_14); +return x_17; +} +} +else +{ +uint8_t x_18; +lean_dec(x_6); +lean_dec(x_5); +x_18 = !lean_is_exclusive(x_8); +if (x_18 == 0) +{ +return x_8; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_8, 0); +x_20 = lean_ctor_get(x_8, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_8); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +return x_21; +} +} +} +} +static lean_object* _init_l_Lake_ExternLib_recComputeDynlib___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":dynlib", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_recComputeDynlib___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_ExternLib_recComputeDynlib___lambda__1___boxed), 7, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_recComputeDynlib(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = l_Lake_ExternLib_recBuildStatic___closed__1; +x_10 = l_Lean_Name_str___override(x_8, x_9); +x_11 = 1; +x_12 = l_Lean_Name_toString(x_10, x_11); +x_13 = l_Lake_ExternLib_recBuildStatic___closed__2; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lake_ExternLib_recComputeDynlib___closed__1; +x_16 = lean_string_append(x_14, x_15); +x_17 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_17, 0, x_1); +x_18 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_18, 0, x_17); +lean_closure_set(x_18, 1, lean_box(0)); +x_19 = l_Lake_ExternLib_recComputeDynlib___closed__2; +x_20 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg), 8, 2); +lean_closure_set(x_20, 0, x_18); +lean_closure_set(x_20, 1, x_19); +x_21 = l_Lake_withRegisterJob___rarg(x_16, x_20, x_2, x_3, x_4, x_5, x_6, x_7); +return x_21; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_recComputeDynlib___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_ExternLib_recComputeDynlib___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_3); +lean_dec(x_2); +return x_8; +} +} +static lean_object* _init_l_Lake_recBuildWithIndex___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("do not know how to build module facet `", 39); +return x_1; +} +} +static lean_object* _init_l_Lake_recBuildWithIndex___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("`", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_recBuildWithIndex___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("do not know how to build package facet `", 40); +return x_1; +} +} +static lean_object* _init_l_Lake_recBuildWithIndex___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("do not know how to build library facet `", 40); +return x_1; +} +} +static lean_object* _init_l_Lake_recBuildWithIndex___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("could not build `", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_recBuildWithIndex___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("` of `", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_recBuildWithIndex___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("` -- target not found", 21); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_recBuildWithIndex(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_1); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_9 = lean_ctor_get(x_1, 0); +x_10 = lean_ctor_get(x_1, 1); +x_11 = lean_ctor_get(x_4, 1); +lean_inc(x_11); +x_12 = l_Lake_Workspace_findModuleFacetConfig_x3f(x_10, x_11); +lean_dec(x_11); +if (lean_obj_tag(x_12) == 0) +{ +uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_13 = 1; +x_14 = l_Lean_Name_toString(x_10, x_13); +x_15 = l_Lake_recBuildWithIndex___closed__1; +x_16 = lean_string_append(x_15, x_14); +lean_dec(x_14); +x_17 = l_Lake_recBuildWithIndex___closed__2; +x_18 = lean_string_append(x_16, x_17); +x_19 = 3; +x_20 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set_uint8(x_20, sizeof(void*)*1, x_19); +x_21 = lean_array_get_size(x_5); +x_22 = lean_array_push(x_5, x_20); +lean_ctor_set_tag(x_1, 1); +lean_ctor_set(x_1, 1, x_22); +lean_ctor_set(x_1, 0, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_1); +lean_ctor_set(x_23, 1, x_6); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_7); +return x_24; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_free_object(x_1); +lean_dec(x_10); +x_25 = lean_ctor_get(x_12, 0); +lean_inc(x_25); +lean_dec(x_12); +x_26 = lean_ctor_get(x_25, 0); +lean_inc(x_26); +lean_dec(x_25); +x_27 = lean_apply_7(x_26, x_9, x_2, x_3, x_4, x_5, x_6, x_7); +return x_27; +} +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_28 = lean_ctor_get(x_1, 0); +x_29 = lean_ctor_get(x_1, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_1); +x_30 = lean_ctor_get(x_4, 1); +lean_inc(x_30); +x_31 = l_Lake_Workspace_findModuleFacetConfig_x3f(x_29, x_30); +lean_dec(x_30); +if (lean_obj_tag(x_31) == 0) +{ +uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_28); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_32 = 1; +x_33 = l_Lean_Name_toString(x_29, x_32); +x_34 = l_Lake_recBuildWithIndex___closed__1; +x_35 = lean_string_append(x_34, x_33); +lean_dec(x_33); +x_36 = l_Lake_recBuildWithIndex___closed__2; +x_37 = lean_string_append(x_35, x_36); +x_38 = 3; +x_39 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set_uint8(x_39, sizeof(void*)*1, x_38); +x_40 = lean_array_get_size(x_5); +x_41 = lean_array_push(x_5, x_39); +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_6); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_7); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +lean_dec(x_29); +x_45 = lean_ctor_get(x_31, 0); +lean_inc(x_45); +lean_dec(x_31); +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +lean_dec(x_45); +x_47 = lean_apply_7(x_46, x_28, x_2, x_3, x_4, x_5, x_6, x_7); +return x_47; +} +} +} +case 1: +{ +uint8_t x_48; +x_48 = !lean_is_exclusive(x_1); +if (x_48 == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_49 = lean_ctor_get(x_1, 0); +x_50 = lean_ctor_get(x_1, 1); +x_51 = lean_ctor_get(x_4, 1); +lean_inc(x_51); +x_52 = l_Lake_Workspace_findPackageFacetConfig_x3f(x_50, x_51); +lean_dec(x_51); +if (lean_obj_tag(x_52) == 0) +{ +uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_49); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_53 = 1; +x_54 = l_Lean_Name_toString(x_50, x_53); +x_55 = l_Lake_recBuildWithIndex___closed__3; +x_56 = lean_string_append(x_55, x_54); +lean_dec(x_54); +x_57 = l_Lake_recBuildWithIndex___closed__2; +x_58 = lean_string_append(x_56, x_57); +x_59 = 3; +x_60 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set_uint8(x_60, sizeof(void*)*1, x_59); +x_61 = lean_array_get_size(x_5); +x_62 = lean_array_push(x_5, x_60); +lean_ctor_set(x_1, 1, x_62); +lean_ctor_set(x_1, 0, x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_1); +lean_ctor_set(x_63, 1, x_6); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_7); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +lean_free_object(x_1); +lean_dec(x_50); +x_65 = lean_ctor_get(x_52, 0); +lean_inc(x_65); +lean_dec(x_52); +x_66 = lean_ctor_get(x_65, 0); +lean_inc(x_66); +lean_dec(x_65); +x_67 = lean_apply_7(x_66, x_49, x_2, x_3, x_4, x_5, x_6, x_7); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_68 = lean_ctor_get(x_1, 0); +x_69 = lean_ctor_get(x_1, 1); +lean_inc(x_69); +lean_inc(x_68); +lean_dec(x_1); +x_70 = lean_ctor_get(x_4, 1); +lean_inc(x_70); +x_71 = l_Lake_Workspace_findPackageFacetConfig_x3f(x_69, x_70); +lean_dec(x_70); +if (lean_obj_tag(x_71) == 0) +{ +uint8_t x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +lean_dec(x_68); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_72 = 1; +x_73 = l_Lean_Name_toString(x_69, x_72); +x_74 = l_Lake_recBuildWithIndex___closed__3; +x_75 = lean_string_append(x_74, x_73); +lean_dec(x_73); +x_76 = l_Lake_recBuildWithIndex___closed__2; +x_77 = lean_string_append(x_75, x_76); +x_78 = 3; +x_79 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_79, 0, x_77); +lean_ctor_set_uint8(x_79, sizeof(void*)*1, x_78); +x_80 = lean_array_get_size(x_5); +x_81 = lean_array_push(x_5, x_79); +x_82 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_82, 0, x_80); +lean_ctor_set(x_82, 1, x_81); +x_83 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_6); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_7); +return x_84; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_69); +x_85 = lean_ctor_get(x_71, 0); +lean_inc(x_85); +lean_dec(x_71); +x_86 = lean_ctor_get(x_85, 0); +lean_inc(x_86); +lean_dec(x_85); +x_87 = lean_apply_7(x_86, x_68, x_2, x_3, x_4, x_5, x_6, x_7); +return x_87; +} +} +} +case 2: +{ +uint8_t x_88; +x_88 = !lean_is_exclusive(x_1); +if (x_88 == 0) +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_89 = lean_ctor_get(x_1, 0); +x_90 = lean_ctor_get(x_1, 1); +x_91 = lean_ctor_get(x_4, 1); +lean_inc(x_91); +x_92 = l_Lake_Workspace_findLibraryFacetConfig_x3f(x_90, x_91); +lean_dec(x_91); +if (lean_obj_tag(x_92) == 0) +{ +uint8_t x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_89); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_93 = 1; +x_94 = l_Lean_Name_toString(x_90, x_93); +x_95 = l_Lake_recBuildWithIndex___closed__4; +x_96 = lean_string_append(x_95, x_94); +lean_dec(x_94); +x_97 = l_Lake_recBuildWithIndex___closed__2; +x_98 = lean_string_append(x_96, x_97); +x_99 = 3; +x_100 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set_uint8(x_100, sizeof(void*)*1, x_99); +x_101 = lean_array_get_size(x_5); +x_102 = lean_array_push(x_5, x_100); +lean_ctor_set_tag(x_1, 1); +lean_ctor_set(x_1, 1, x_102); +lean_ctor_set(x_1, 0, x_101); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_1); +lean_ctor_set(x_103, 1, x_6); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_7); +return x_104; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_free_object(x_1); +lean_dec(x_90); +x_105 = lean_ctor_get(x_92, 0); +lean_inc(x_105); +lean_dec(x_92); +x_106 = lean_ctor_get(x_105, 0); +lean_inc(x_106); +lean_dec(x_105); +x_107 = lean_apply_7(x_106, x_89, x_2, x_3, x_4, x_5, x_6, x_7); +return x_107; +} +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_108 = lean_ctor_get(x_1, 0); +x_109 = lean_ctor_get(x_1, 1); +lean_inc(x_109); +lean_inc(x_108); +lean_dec(x_1); +x_110 = lean_ctor_get(x_4, 1); +lean_inc(x_110); +x_111 = l_Lake_Workspace_findLibraryFacetConfig_x3f(x_109, x_110); +lean_dec(x_110); +if (lean_obj_tag(x_111) == 0) +{ +uint8_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_108); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_112 = 1; +x_113 = l_Lean_Name_toString(x_109, x_112); +x_114 = l_Lake_recBuildWithIndex___closed__4; +x_115 = lean_string_append(x_114, x_113); +lean_dec(x_113); +x_116 = l_Lake_recBuildWithIndex___closed__2; +x_117 = lean_string_append(x_115, x_116); +x_118 = 3; +x_119 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_119, 0, x_117); +lean_ctor_set_uint8(x_119, sizeof(void*)*1, x_118); +x_120 = lean_array_get_size(x_5); +x_121 = lean_array_push(x_5, x_119); +x_122 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_122, 0, x_120); +lean_ctor_set(x_122, 1, x_121); +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_122); +lean_ctor_set(x_123, 1, x_6); +x_124 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_7); +return x_124; +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; +lean_dec(x_109); +x_125 = lean_ctor_get(x_111, 0); +lean_inc(x_125); +lean_dec(x_111); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_apply_7(x_126, x_108, x_2, x_3, x_4, x_5, x_6, x_7); +return x_127; +} +} +} +case 3: +{ +lean_object* x_128; lean_object* x_129; +x_128 = lean_ctor_get(x_1, 0); +lean_inc(x_128); +lean_dec(x_1); +x_129 = l_Lake_LeanExe_recBuildExe(x_128, x_2, x_3, x_4, x_5, x_6, x_7); +return x_129; +} +case 4: +{ +lean_object* x_130; lean_object* x_131; +x_130 = lean_ctor_get(x_1, 0); +lean_inc(x_130); +lean_dec(x_1); +x_131 = l_Lake_ExternLib_recBuildStatic(x_130, x_2, x_3, x_4, x_5, x_6, x_7); +return x_131; +} +case 5: +{ +lean_object* x_132; lean_object* x_133; +x_132 = lean_ctor_get(x_1, 0); +lean_inc(x_132); +lean_dec(x_1); +x_133 = l_Lake_ExternLib_recBuildShared(x_132, x_2, x_3, x_4, x_5, x_6, x_7); +return x_133; +} +case 6: +{ +lean_object* x_134; lean_object* x_135; +x_134 = lean_ctor_get(x_1, 0); +lean_inc(x_134); +lean_dec(x_1); +x_135 = l_Lake_ExternLib_recComputeDynlib(x_134, x_2, x_3, x_4, x_5, x_6, x_7); +return x_135; +} +default: +{ +uint8_t x_136; +x_136 = !lean_is_exclusive(x_1); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_137 = lean_ctor_get(x_1, 0); +x_138 = lean_ctor_get(x_1, 1); +x_139 = l_Lake_Package_findTargetConfig_x3f(x_138, x_137); +if (lean_obj_tag(x_139) == 0) +{ +uint8_t x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; uint8_t x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_140 = 1; +x_141 = l_Lean_Name_toString(x_138, x_140); +x_142 = l_Lake_recBuildWithIndex___closed__5; +x_143 = lean_string_append(x_142, x_141); +lean_dec(x_141); +x_144 = l_Lake_recBuildWithIndex___closed__6; +x_145 = lean_string_append(x_143, x_144); +x_146 = lean_ctor_get(x_137, 2); +lean_inc(x_146); +lean_dec(x_137); +x_147 = lean_ctor_get(x_146, 2); +lean_inc(x_147); +lean_dec(x_146); +x_148 = l_Lean_Name_toString(x_147, x_140); +x_149 = lean_string_append(x_145, x_148); +lean_dec(x_148); +x_150 = l_Lake_recBuildWithIndex___closed__7; +x_151 = lean_string_append(x_149, x_150); +x_152 = 3; +x_153 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_153, 0, x_151); +lean_ctor_set_uint8(x_153, sizeof(void*)*1, x_152); +x_154 = lean_array_get_size(x_5); +x_155 = lean_array_push(x_5, x_153); +lean_ctor_set_tag(x_1, 1); +lean_ctor_set(x_1, 1, x_155); +lean_ctor_set(x_1, 0, x_154); +x_156 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_156, 0, x_1); +lean_ctor_set(x_156, 1, x_6); +x_157 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_157, 0, x_156); +lean_ctor_set(x_157, 1, x_7); +return x_157; +} +else +{ +lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_free_object(x_1); +lean_dec(x_138); +x_158 = lean_ctor_get(x_139, 0); +lean_inc(x_158); +lean_dec(x_139); +x_159 = lean_ctor_get(x_158, 0); +lean_inc(x_159); +lean_dec(x_158); +x_160 = lean_apply_7(x_159, x_137, x_2, x_3, x_4, x_5, x_6, x_7); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_ctor_get(x_1, 0); +x_162 = lean_ctor_get(x_1, 1); +lean_inc(x_162); +lean_inc(x_161); +lean_dec(x_1); +x_163 = l_Lake_Package_findTargetConfig_x3f(x_162, x_161); +if (lean_obj_tag(x_163) == 0) +{ +uint8_t x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; uint8_t x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_164 = 1; +x_165 = l_Lean_Name_toString(x_162, x_164); +x_166 = l_Lake_recBuildWithIndex___closed__5; +x_167 = lean_string_append(x_166, x_165); +lean_dec(x_165); +x_168 = l_Lake_recBuildWithIndex___closed__6; +x_169 = lean_string_append(x_167, x_168); +x_170 = lean_ctor_get(x_161, 2); +lean_inc(x_170); +lean_dec(x_161); +x_171 = lean_ctor_get(x_170, 2); +lean_inc(x_171); +lean_dec(x_170); +x_172 = l_Lean_Name_toString(x_171, x_164); +x_173 = lean_string_append(x_169, x_172); +lean_dec(x_172); +x_174 = l_Lake_recBuildWithIndex___closed__7; +x_175 = lean_string_append(x_173, x_174); +x_176 = 3; +x_177 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_177, 0, x_175); +lean_ctor_set_uint8(x_177, sizeof(void*)*1, x_176); +x_178 = lean_array_get_size(x_5); +x_179 = lean_array_push(x_5, x_177); +x_180 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_180, 0, x_178); +lean_ctor_set(x_180, 1, x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_6); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_7); +return x_182; +} +else +{ +lean_object* x_183; lean_object* x_184; lean_object* x_185; +lean_dec(x_162); +x_183 = lean_ctor_get(x_163, 0); +lean_inc(x_183); +lean_dec(x_163); +x_184 = lean_ctor_get(x_183, 0); +lean_inc(x_184); +lean_dec(x_183); +x_185 = lean_apply_7(x_184, x_161, x_2, x_3, x_4, x_5, x_6, x_7); +return x_185; +} +} +} +} +} +} +LEAN_EXPORT uint8_t l_List_elem___at_Lake_FetchM_run___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(x_4, x_1); +if (x_6 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_8; +x_8 = 1; +return x_8; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_FetchM_run___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_3; +x_3 = lean_box(0); +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_ctor_get(x_1, 2); +x_7 = lean_ctor_get(x_1, 3); +x_8 = l_Lake_BuildKey_quickCmp(x_2, x_5); +switch (x_8) { +case 0: +{ +x_1 = x_4; +goto _start; +} +case 1: +{ +lean_object* x_10; +lean_inc(x_6); +x_10 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_10, 0, x_6); +return x_10; +} +default: +{ +x_1 = x_7; +goto _start; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; uint8_t x_5; lean_object* x_6; +x_4 = lean_box(0); +x_5 = 0; +x_6 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_6, 0, x_4); +lean_ctor_set(x_6, 1, x_2); +lean_ctor_set(x_6, 2, x_3); +lean_ctor_set(x_6, 3, x_4); +lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5); +return x_6; +} +else +{ +uint8_t x_7; +x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4); +if (x_7 == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_1); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_9 = lean_ctor_get(x_1, 0); +x_10 = lean_ctor_get(x_1, 1); +x_11 = lean_ctor_get(x_1, 2); +x_12 = lean_ctor_get(x_1, 3); +x_13 = l_Lake_BuildKey_quickCmp(x_2, x_10); +switch (x_13) { +case 0: +{ +lean_object* x_14; uint8_t x_15; +x_14 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_9, x_2, x_3); +x_15 = 0; +lean_ctor_set(x_1, 0, x_14); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15); +return x_1; +} +case 1: +{ +uint8_t x_16; +lean_dec(x_11); +lean_dec(x_10); +x_16 = 0; +lean_ctor_set(x_1, 2, x_3); +lean_ctor_set(x_1, 1, x_2); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_16); +return x_1; +} +default: +{ +lean_object* x_17; uint8_t x_18; +x_17 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_12, x_2, x_3); +x_18 = 0; +lean_ctor_set(x_1, 3, x_17); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_18); +return x_1; +} +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; +x_19 = lean_ctor_get(x_1, 0); +x_20 = lean_ctor_get(x_1, 1); +x_21 = lean_ctor_get(x_1, 2); +x_22 = lean_ctor_get(x_1, 3); +lean_inc(x_22); +lean_inc(x_21); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_1); +x_23 = l_Lake_BuildKey_quickCmp(x_2, x_20); +switch (x_23) { +case 0: +{ +lean_object* x_24; uint8_t x_25; lean_object* x_26; +x_24 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_19, x_2, x_3); +x_25 = 0; +x_26 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_20); +lean_ctor_set(x_26, 2, x_21); +lean_ctor_set(x_26, 3, x_22); +lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_25); +return x_26; +} +case 1: +{ +uint8_t x_27; lean_object* x_28; +lean_dec(x_21); +lean_dec(x_20); +x_27 = 0; +x_28 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_28, 0, x_19); +lean_ctor_set(x_28, 1, x_2); +lean_ctor_set(x_28, 2, x_3); +lean_ctor_set(x_28, 3, x_22); +lean_ctor_set_uint8(x_28, sizeof(void*)*4, x_27); +return x_28; +} +default: +{ +lean_object* x_29; uint8_t x_30; lean_object* x_31; +x_29 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_22, x_2, x_3); +x_30 = 0; +x_31 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_31, 0, x_19); +lean_ctor_set(x_31, 1, x_20); +lean_ctor_set(x_31, 2, x_21); +lean_ctor_set(x_31, 3, x_29); +lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_30); +return x_31; +} +} +} +} +else +{ +uint8_t x_32; +x_32 = !lean_is_exclusive(x_1); +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_33 = lean_ctor_get(x_1, 0); +x_34 = lean_ctor_get(x_1, 1); +x_35 = lean_ctor_get(x_1, 2); +x_36 = lean_ctor_get(x_1, 3); +x_37 = l_Lake_BuildKey_quickCmp(x_2, x_34); +switch (x_37) { +case 0: +{ +lean_object* x_38; uint8_t x_39; +x_38 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_33, x_2, x_3); +x_39 = lean_ctor_get_uint8(x_38, sizeof(void*)*4); +if (x_39 == 0) +{ +lean_object* x_40; +x_40 = lean_ctor_get(x_38, 0); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; +x_41 = lean_ctor_get(x_38, 3); +lean_inc(x_41); +if (lean_obj_tag(x_41) == 0) +{ +uint8_t x_42; +x_42 = !lean_is_exclusive(x_38); +if (x_42 == 0) +{ +lean_object* x_43; lean_object* x_44; uint8_t x_45; +x_43 = lean_ctor_get(x_38, 3); +lean_dec(x_43); +x_44 = lean_ctor_get(x_38, 0); +lean_dec(x_44); +lean_ctor_set(x_38, 0, x_41); +x_45 = 1; +lean_ctor_set(x_1, 0, x_38); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_45); +return x_1; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_46 = lean_ctor_get(x_38, 1); +x_47 = lean_ctor_get(x_38, 2); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_38); +x_48 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_48, 0, x_41); +lean_ctor_set(x_48, 1, x_46); +lean_ctor_set(x_48, 2, x_47); +lean_ctor_set(x_48, 3, x_41); +lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_39); +x_49 = 1; +lean_ctor_set(x_1, 0, x_48); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49); +return x_1; +} +} +else +{ +uint8_t x_50; +x_50 = lean_ctor_get_uint8(x_41, sizeof(void*)*4); +if (x_50 == 0) +{ +uint8_t x_51; +x_51 = !lean_is_exclusive(x_38); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_52 = lean_ctor_get(x_38, 1); +x_53 = lean_ctor_get(x_38, 2); +x_54 = lean_ctor_get(x_38, 3); +lean_dec(x_54); +x_55 = lean_ctor_get(x_38, 0); +lean_dec(x_55); +x_56 = !lean_is_exclusive(x_41); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; uint8_t x_62; +x_57 = lean_ctor_get(x_41, 0); +x_58 = lean_ctor_get(x_41, 1); +x_59 = lean_ctor_get(x_41, 2); +x_60 = lean_ctor_get(x_41, 3); +x_61 = 1; +lean_ctor_set(x_41, 3, x_57); +lean_ctor_set(x_41, 2, x_53); +lean_ctor_set(x_41, 1, x_52); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_61); +lean_ctor_set(x_38, 3, x_36); +lean_ctor_set(x_38, 2, x_35); +lean_ctor_set(x_38, 1, x_34); +lean_ctor_set(x_38, 0, x_60); +lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_61); +x_62 = 0; +lean_ctor_set(x_1, 3, x_38); +lean_ctor_set(x_1, 2, x_59); +lean_ctor_set(x_1, 1, x_58); +lean_ctor_set(x_1, 0, x_41); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_62); +return x_1; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; uint8_t x_69; +x_63 = lean_ctor_get(x_41, 0); +x_64 = lean_ctor_get(x_41, 1); +x_65 = lean_ctor_get(x_41, 2); +x_66 = lean_ctor_get(x_41, 3); +lean_inc(x_66); +lean_inc(x_65); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_41); +x_67 = 1; +x_68 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_68, 0, x_40); +lean_ctor_set(x_68, 1, x_52); +lean_ctor_set(x_68, 2, x_53); +lean_ctor_set(x_68, 3, x_63); +lean_ctor_set_uint8(x_68, sizeof(void*)*4, x_67); +lean_ctor_set(x_38, 3, x_36); +lean_ctor_set(x_38, 2, x_35); +lean_ctor_set(x_38, 1, x_34); +lean_ctor_set(x_38, 0, x_66); +lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_67); +x_69 = 0; +lean_ctor_set(x_1, 3, x_38); +lean_ctor_set(x_1, 2, x_65); +lean_ctor_set(x_1, 1, x_64); +lean_ctor_set(x_1, 0, x_68); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_69); +return x_1; +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_70 = lean_ctor_get(x_38, 1); +x_71 = lean_ctor_get(x_38, 2); +lean_inc(x_71); +lean_inc(x_70); +lean_dec(x_38); +x_72 = lean_ctor_get(x_41, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_41, 1); +lean_inc(x_73); +x_74 = lean_ctor_get(x_41, 2); +lean_inc(x_74); +x_75 = lean_ctor_get(x_41, 3); +lean_inc(x_75); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + lean_ctor_release(x_41, 2); + lean_ctor_release(x_41, 3); + x_76 = x_41; +} else { + lean_dec_ref(x_41); + x_76 = lean_box(0); +} +x_77 = 1; +if (lean_is_scalar(x_76)) { + x_78 = lean_alloc_ctor(1, 4, 1); +} else { + x_78 = x_76; +} +lean_ctor_set(x_78, 0, x_40); +lean_ctor_set(x_78, 1, x_70); +lean_ctor_set(x_78, 2, x_71); +lean_ctor_set(x_78, 3, x_72); +lean_ctor_set_uint8(x_78, sizeof(void*)*4, x_77); +x_79 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_79, 0, x_75); +lean_ctor_set(x_79, 1, x_34); +lean_ctor_set(x_79, 2, x_35); +lean_ctor_set(x_79, 3, x_36); +lean_ctor_set_uint8(x_79, sizeof(void*)*4, x_77); +x_80 = 0; +lean_ctor_set(x_1, 3, x_79); +lean_ctor_set(x_1, 2, x_74); +lean_ctor_set(x_1, 1, x_73); +lean_ctor_set(x_1, 0, x_78); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_80); +return x_1; +} +} +else +{ +uint8_t x_81; +lean_free_object(x_1); +x_81 = !lean_is_exclusive(x_41); +if (x_81 == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; +x_82 = lean_ctor_get(x_41, 3); +lean_dec(x_82); +x_83 = lean_ctor_get(x_41, 2); +lean_dec(x_83); +x_84 = lean_ctor_get(x_41, 1); +lean_dec(x_84); +x_85 = lean_ctor_get(x_41, 0); +lean_dec(x_85); +x_86 = 1; +lean_ctor_set(x_41, 3, x_36); +lean_ctor_set(x_41, 2, x_35); +lean_ctor_set(x_41, 1, x_34); +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_86); +return x_41; +} +else +{ +uint8_t x_87; lean_object* x_88; +lean_dec(x_41); +x_87 = 1; +x_88 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_88, 0, x_38); +lean_ctor_set(x_88, 1, x_34); +lean_ctor_set(x_88, 2, x_35); +lean_ctor_set(x_88, 3, x_36); +lean_ctor_set_uint8(x_88, sizeof(void*)*4, x_87); +return x_88; +} +} +} +} +else +{ +uint8_t x_89; +x_89 = lean_ctor_get_uint8(x_40, sizeof(void*)*4); +if (x_89 == 0) +{ +uint8_t x_90; +x_90 = !lean_is_exclusive(x_38); +if (x_90 == 0) +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_91 = lean_ctor_get(x_38, 1); +x_92 = lean_ctor_get(x_38, 2); +x_93 = lean_ctor_get(x_38, 3); +x_94 = lean_ctor_get(x_38, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_40); +if (x_95 == 0) +{ +uint8_t x_96; uint8_t x_97; +x_96 = 1; +lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_96); +lean_ctor_set(x_38, 3, x_36); +lean_ctor_set(x_38, 2, x_35); +lean_ctor_set(x_38, 1, x_34); +lean_ctor_set(x_38, 0, x_93); +lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_96); +x_97 = 0; +lean_ctor_set(x_1, 3, x_38); +lean_ctor_set(x_1, 2, x_92); +lean_ctor_set(x_1, 1, x_91); +lean_ctor_set(x_1, 0, x_40); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_97); +return x_1; +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; uint8_t x_104; +x_98 = lean_ctor_get(x_40, 0); +x_99 = lean_ctor_get(x_40, 1); +x_100 = lean_ctor_get(x_40, 2); +x_101 = lean_ctor_get(x_40, 3); +lean_inc(x_101); +lean_inc(x_100); +lean_inc(x_99); +lean_inc(x_98); +lean_dec(x_40); +x_102 = 1; +x_103 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set(x_103, 1, x_99); +lean_ctor_set(x_103, 2, x_100); +lean_ctor_set(x_103, 3, x_101); +lean_ctor_set_uint8(x_103, sizeof(void*)*4, x_102); +lean_ctor_set(x_38, 3, x_36); +lean_ctor_set(x_38, 2, x_35); +lean_ctor_set(x_38, 1, x_34); +lean_ctor_set(x_38, 0, x_93); +lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_102); +x_104 = 0; +lean_ctor_set(x_1, 3, x_38); +lean_ctor_set(x_1, 2, x_92); +lean_ctor_set(x_1, 1, x_91); +lean_ctor_set(x_1, 0, x_103); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_104); +return x_1; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_105 = lean_ctor_get(x_38, 1); +x_106 = lean_ctor_get(x_38, 2); +x_107 = lean_ctor_get(x_38, 3); +lean_inc(x_107); +lean_inc(x_106); +lean_inc(x_105); +lean_dec(x_38); +x_108 = lean_ctor_get(x_40, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_40, 1); +lean_inc(x_109); +x_110 = lean_ctor_get(x_40, 2); +lean_inc(x_110); +x_111 = lean_ctor_get(x_40, 3); +lean_inc(x_111); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + lean_ctor_release(x_40, 2); + lean_ctor_release(x_40, 3); + x_112 = x_40; +} else { + lean_dec_ref(x_40); + x_112 = lean_box(0); +} +x_113 = 1; +if (lean_is_scalar(x_112)) { + x_114 = lean_alloc_ctor(1, 4, 1); +} else { + x_114 = x_112; +} +lean_ctor_set(x_114, 0, x_108); +lean_ctor_set(x_114, 1, x_109); +lean_ctor_set(x_114, 2, x_110); +lean_ctor_set(x_114, 3, x_111); +lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113); +x_115 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_115, 0, x_107); +lean_ctor_set(x_115, 1, x_34); +lean_ctor_set(x_115, 2, x_35); +lean_ctor_set(x_115, 3, x_36); +lean_ctor_set_uint8(x_115, sizeof(void*)*4, x_113); +x_116 = 0; +lean_ctor_set(x_1, 3, x_115); +lean_ctor_set(x_1, 2, x_106); +lean_ctor_set(x_1, 1, x_105); +lean_ctor_set(x_1, 0, x_114); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_116); +return x_1; +} +} +else +{ +lean_object* x_117; +x_117 = lean_ctor_get(x_38, 3); +lean_inc(x_117); +if (lean_obj_tag(x_117) == 0) +{ +uint8_t x_118; +lean_free_object(x_1); +x_118 = !lean_is_exclusive(x_40); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; +x_119 = lean_ctor_get(x_40, 3); +lean_dec(x_119); +x_120 = lean_ctor_get(x_40, 2); +lean_dec(x_120); +x_121 = lean_ctor_get(x_40, 1); +lean_dec(x_121); +x_122 = lean_ctor_get(x_40, 0); +lean_dec(x_122); +x_123 = 1; +lean_ctor_set(x_40, 3, x_36); +lean_ctor_set(x_40, 2, x_35); +lean_ctor_set(x_40, 1, x_34); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_123); +return x_40; +} +else +{ +uint8_t x_124; lean_object* x_125; +lean_dec(x_40); +x_124 = 1; +x_125 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_125, 0, x_38); +lean_ctor_set(x_125, 1, x_34); +lean_ctor_set(x_125, 2, x_35); +lean_ctor_set(x_125, 3, x_36); +lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124); +return x_125; +} +} +else +{ +uint8_t x_126; +x_126 = lean_ctor_get_uint8(x_117, sizeof(void*)*4); +if (x_126 == 0) +{ +uint8_t x_127; +lean_free_object(x_1); +x_127 = !lean_is_exclusive(x_38); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; uint8_t x_132; +x_128 = lean_ctor_get(x_38, 1); +x_129 = lean_ctor_get(x_38, 2); +x_130 = lean_ctor_get(x_38, 3); +lean_dec(x_130); +x_131 = lean_ctor_get(x_38, 0); +lean_dec(x_131); +x_132 = !lean_is_exclusive(x_117); +if (x_132 == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; uint8_t x_137; uint8_t x_138; +x_133 = lean_ctor_get(x_117, 0); +x_134 = lean_ctor_get(x_117, 1); +x_135 = lean_ctor_get(x_117, 2); +x_136 = lean_ctor_get(x_117, 3); +x_137 = 1; +lean_inc(x_40); +lean_ctor_set(x_117, 3, x_133); +lean_ctor_set(x_117, 2, x_129); +lean_ctor_set(x_117, 1, x_128); +lean_ctor_set(x_117, 0, x_40); +x_138 = !lean_is_exclusive(x_40); +if (x_138 == 0) +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; uint8_t x_143; +x_139 = lean_ctor_get(x_40, 3); +lean_dec(x_139); +x_140 = lean_ctor_get(x_40, 2); +lean_dec(x_140); +x_141 = lean_ctor_get(x_40, 1); +lean_dec(x_141); +x_142 = lean_ctor_get(x_40, 0); +lean_dec(x_142); +lean_ctor_set_uint8(x_117, sizeof(void*)*4, x_137); +lean_ctor_set(x_40, 3, x_36); +lean_ctor_set(x_40, 2, x_35); +lean_ctor_set(x_40, 1, x_34); +lean_ctor_set(x_40, 0, x_136); +lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_137); +x_143 = 0; +lean_ctor_set(x_38, 3, x_40); +lean_ctor_set(x_38, 2, x_135); +lean_ctor_set(x_38, 1, x_134); +lean_ctor_set(x_38, 0, x_117); +lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_143); +return x_38; +} +else +{ +lean_object* x_144; uint8_t x_145; +lean_dec(x_40); +lean_ctor_set_uint8(x_117, sizeof(void*)*4, x_137); +x_144 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_144, 0, x_136); +lean_ctor_set(x_144, 1, x_34); +lean_ctor_set(x_144, 2, x_35); +lean_ctor_set(x_144, 3, x_36); +lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_137); +x_145 = 0; +lean_ctor_set(x_38, 3, x_144); +lean_ctor_set(x_38, 2, x_135); +lean_ctor_set(x_38, 1, x_134); +lean_ctor_set(x_38, 0, x_117); +lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_145); +return x_38; +} +} +else +{ +lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; uint8_t x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; +x_146 = lean_ctor_get(x_117, 0); +x_147 = lean_ctor_get(x_117, 1); +x_148 = lean_ctor_get(x_117, 2); +x_149 = lean_ctor_get(x_117, 3); +lean_inc(x_149); +lean_inc(x_148); +lean_inc(x_147); +lean_inc(x_146); +lean_dec(x_117); +x_150 = 1; +lean_inc(x_40); +x_151 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_151, 0, x_40); +lean_ctor_set(x_151, 1, x_128); +lean_ctor_set(x_151, 2, x_129); +lean_ctor_set(x_151, 3, x_146); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + lean_ctor_release(x_40, 2); + lean_ctor_release(x_40, 3); + x_152 = x_40; +} else { + lean_dec_ref(x_40); + x_152 = lean_box(0); +} +lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_150); +if (lean_is_scalar(x_152)) { + x_153 = lean_alloc_ctor(1, 4, 1); +} else { + x_153 = x_152; +} +lean_ctor_set(x_153, 0, x_149); +lean_ctor_set(x_153, 1, x_34); +lean_ctor_set(x_153, 2, x_35); +lean_ctor_set(x_153, 3, x_36); +lean_ctor_set_uint8(x_153, sizeof(void*)*4, x_150); +x_154 = 0; +lean_ctor_set(x_38, 3, x_153); +lean_ctor_set(x_38, 2, x_148); +lean_ctor_set(x_38, 1, x_147); +lean_ctor_set(x_38, 0, x_151); +lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_154); +return x_38; +} +} +else +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; uint8_t x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; uint8_t x_166; lean_object* x_167; +x_155 = lean_ctor_get(x_38, 1); +x_156 = lean_ctor_get(x_38, 2); +lean_inc(x_156); +lean_inc(x_155); +lean_dec(x_38); +x_157 = lean_ctor_get(x_117, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_117, 1); +lean_inc(x_158); +x_159 = lean_ctor_get(x_117, 2); +lean_inc(x_159); +x_160 = lean_ctor_get(x_117, 3); +lean_inc(x_160); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + lean_ctor_release(x_117, 2); + lean_ctor_release(x_117, 3); + x_161 = x_117; +} else { + lean_dec_ref(x_117); + x_161 = lean_box(0); +} +x_162 = 1; +lean_inc(x_40); +if (lean_is_scalar(x_161)) { + x_163 = lean_alloc_ctor(1, 4, 1); +} else { + x_163 = x_161; +} +lean_ctor_set(x_163, 0, x_40); +lean_ctor_set(x_163, 1, x_155); +lean_ctor_set(x_163, 2, x_156); +lean_ctor_set(x_163, 3, x_157); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + lean_ctor_release(x_40, 2); + lean_ctor_release(x_40, 3); + x_164 = x_40; +} else { + lean_dec_ref(x_40); + x_164 = lean_box(0); +} +lean_ctor_set_uint8(x_163, sizeof(void*)*4, x_162); +if (lean_is_scalar(x_164)) { + x_165 = lean_alloc_ctor(1, 4, 1); +} else { + x_165 = x_164; +} +lean_ctor_set(x_165, 0, x_160); +lean_ctor_set(x_165, 1, x_34); +lean_ctor_set(x_165, 2, x_35); +lean_ctor_set(x_165, 3, x_36); +lean_ctor_set_uint8(x_165, sizeof(void*)*4, x_162); +x_166 = 0; +x_167 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_167, 0, x_163); +lean_ctor_set(x_167, 1, x_158); +lean_ctor_set(x_167, 2, x_159); +lean_ctor_set(x_167, 3, x_165); +lean_ctor_set_uint8(x_167, sizeof(void*)*4, x_166); +return x_167; +} +} +else +{ +uint8_t x_168; +x_168 = !lean_is_exclusive(x_38); +if (x_168 == 0) +{ +lean_object* x_169; lean_object* x_170; uint8_t x_171; +x_169 = lean_ctor_get(x_38, 3); +lean_dec(x_169); +x_170 = lean_ctor_get(x_38, 0); +lean_dec(x_170); +x_171 = !lean_is_exclusive(x_40); +if (x_171 == 0) +{ +uint8_t x_172; +lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_126); +x_172 = 1; +lean_ctor_set(x_1, 0, x_38); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_172); +return x_1; +} +else +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_40, 0); +x_174 = lean_ctor_get(x_40, 1); +x_175 = lean_ctor_get(x_40, 2); +x_176 = lean_ctor_get(x_40, 3); +lean_inc(x_176); +lean_inc(x_175); +lean_inc(x_174); +lean_inc(x_173); +lean_dec(x_40); +x_177 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_177, 0, x_173); +lean_ctor_set(x_177, 1, x_174); +lean_ctor_set(x_177, 2, x_175); +lean_ctor_set(x_177, 3, x_176); +lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_126); +lean_ctor_set(x_38, 0, x_177); +x_178 = 1; +lean_ctor_set(x_1, 0, x_38); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_178); +return x_1; +} +} +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; uint8_t x_188; +x_179 = lean_ctor_get(x_38, 1); +x_180 = lean_ctor_get(x_38, 2); +lean_inc(x_180); +lean_inc(x_179); +lean_dec(x_38); +x_181 = lean_ctor_get(x_40, 0); +lean_inc(x_181); +x_182 = lean_ctor_get(x_40, 1); +lean_inc(x_182); +x_183 = lean_ctor_get(x_40, 2); +lean_inc(x_183); +x_184 = lean_ctor_get(x_40, 3); +lean_inc(x_184); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + lean_ctor_release(x_40, 2); + lean_ctor_release(x_40, 3); + x_185 = x_40; +} else { + lean_dec_ref(x_40); + x_185 = lean_box(0); +} +if (lean_is_scalar(x_185)) { + x_186 = lean_alloc_ctor(1, 4, 1); +} else { + x_186 = x_185; +} +lean_ctor_set(x_186, 0, x_181); +lean_ctor_set(x_186, 1, x_182); +lean_ctor_set(x_186, 2, x_183); +lean_ctor_set(x_186, 3, x_184); +lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_126); +x_187 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_179); +lean_ctor_set(x_187, 2, x_180); +lean_ctor_set(x_187, 3, x_117); +lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_39); +x_188 = 1; +lean_ctor_set(x_1, 0, x_187); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188); +return x_1; +} +} +} +} +} +} +else +{ +uint8_t x_189; +x_189 = 1; +lean_ctor_set(x_1, 0, x_38); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189); +return x_1; +} +} +case 1: +{ +uint8_t x_190; +lean_dec(x_35); +lean_dec(x_34); +x_190 = 1; +lean_ctor_set(x_1, 2, x_3); +lean_ctor_set(x_1, 1, x_2); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_190); +return x_1; +} +default: +{ +lean_object* x_191; uint8_t x_192; +x_191 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_36, x_2, x_3); +x_192 = lean_ctor_get_uint8(x_191, sizeof(void*)*4); +if (x_192 == 0) +{ +lean_object* x_193; +x_193 = lean_ctor_get(x_191, 0); +lean_inc(x_193); +if (lean_obj_tag(x_193) == 0) +{ +lean_object* x_194; +x_194 = lean_ctor_get(x_191, 3); +lean_inc(x_194); +if (lean_obj_tag(x_194) == 0) +{ +uint8_t x_195; +x_195 = !lean_is_exclusive(x_191); +if (x_195 == 0) +{ +lean_object* x_196; lean_object* x_197; uint8_t x_198; +x_196 = lean_ctor_get(x_191, 3); +lean_dec(x_196); +x_197 = lean_ctor_get(x_191, 0); +lean_dec(x_197); +lean_ctor_set(x_191, 0, x_194); +x_198 = 1; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_198); +return x_1; +} +else +{ +lean_object* x_199; lean_object* x_200; lean_object* x_201; uint8_t x_202; +x_199 = lean_ctor_get(x_191, 1); +x_200 = lean_ctor_get(x_191, 2); +lean_inc(x_200); +lean_inc(x_199); +lean_dec(x_191); +x_201 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_201, 0, x_194); +lean_ctor_set(x_201, 1, x_199); +lean_ctor_set(x_201, 2, x_200); +lean_ctor_set(x_201, 3, x_194); +lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_192); +x_202 = 1; +lean_ctor_set(x_1, 3, x_201); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202); +return x_1; +} +} +else +{ +uint8_t x_203; +x_203 = lean_ctor_get_uint8(x_194, sizeof(void*)*4); +if (x_203 == 0) +{ +uint8_t x_204; +x_204 = !lean_is_exclusive(x_191); +if (x_204 == 0) +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; uint8_t x_209; +x_205 = lean_ctor_get(x_191, 1); +x_206 = lean_ctor_get(x_191, 2); +x_207 = lean_ctor_get(x_191, 3); +lean_dec(x_207); +x_208 = lean_ctor_get(x_191, 0); +lean_dec(x_208); +x_209 = !lean_is_exclusive(x_194); +if (x_209 == 0) +{ +lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; uint8_t x_215; +x_210 = lean_ctor_get(x_194, 0); +x_211 = lean_ctor_get(x_194, 1); +x_212 = lean_ctor_get(x_194, 2); +x_213 = lean_ctor_get(x_194, 3); +x_214 = 1; +lean_ctor_set(x_194, 3, x_193); +lean_ctor_set(x_194, 2, x_35); +lean_ctor_set(x_194, 1, x_34); +lean_ctor_set(x_194, 0, x_33); +lean_ctor_set_uint8(x_194, sizeof(void*)*4, x_214); +lean_ctor_set(x_191, 3, x_213); +lean_ctor_set(x_191, 2, x_212); +lean_ctor_set(x_191, 1, x_211); +lean_ctor_set(x_191, 0, x_210); +lean_ctor_set_uint8(x_191, sizeof(void*)*4, x_214); +x_215 = 0; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set(x_1, 2, x_206); +lean_ctor_set(x_1, 1, x_205); +lean_ctor_set(x_1, 0, x_194); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_215); +return x_1; +} +else +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; uint8_t x_220; lean_object* x_221; uint8_t x_222; +x_216 = lean_ctor_get(x_194, 0); +x_217 = lean_ctor_get(x_194, 1); +x_218 = lean_ctor_get(x_194, 2); +x_219 = lean_ctor_get(x_194, 3); +lean_inc(x_219); +lean_inc(x_218); +lean_inc(x_217); +lean_inc(x_216); +lean_dec(x_194); +x_220 = 1; +x_221 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_221, 0, x_33); +lean_ctor_set(x_221, 1, x_34); +lean_ctor_set(x_221, 2, x_35); +lean_ctor_set(x_221, 3, x_193); +lean_ctor_set_uint8(x_221, sizeof(void*)*4, x_220); +lean_ctor_set(x_191, 3, x_219); +lean_ctor_set(x_191, 2, x_218); +lean_ctor_set(x_191, 1, x_217); +lean_ctor_set(x_191, 0, x_216); +lean_ctor_set_uint8(x_191, sizeof(void*)*4, x_220); +x_222 = 0; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set(x_1, 2, x_206); +lean_ctor_set(x_1, 1, x_205); +lean_ctor_set(x_1, 0, x_221); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_222); +return x_1; +} +} +else +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; lean_object* x_231; lean_object* x_232; uint8_t x_233; +x_223 = lean_ctor_get(x_191, 1); +x_224 = lean_ctor_get(x_191, 2); +lean_inc(x_224); +lean_inc(x_223); +lean_dec(x_191); +x_225 = lean_ctor_get(x_194, 0); +lean_inc(x_225); +x_226 = lean_ctor_get(x_194, 1); +lean_inc(x_226); +x_227 = lean_ctor_get(x_194, 2); +lean_inc(x_227); +x_228 = lean_ctor_get(x_194, 3); +lean_inc(x_228); +if (lean_is_exclusive(x_194)) { + lean_ctor_release(x_194, 0); + lean_ctor_release(x_194, 1); + lean_ctor_release(x_194, 2); + lean_ctor_release(x_194, 3); + x_229 = x_194; +} else { + lean_dec_ref(x_194); + x_229 = lean_box(0); +} +x_230 = 1; +if (lean_is_scalar(x_229)) { + x_231 = lean_alloc_ctor(1, 4, 1); +} else { + x_231 = x_229; +} +lean_ctor_set(x_231, 0, x_33); +lean_ctor_set(x_231, 1, x_34); +lean_ctor_set(x_231, 2, x_35); +lean_ctor_set(x_231, 3, x_193); +lean_ctor_set_uint8(x_231, sizeof(void*)*4, x_230); +x_232 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_232, 0, x_225); +lean_ctor_set(x_232, 1, x_226); +lean_ctor_set(x_232, 2, x_227); +lean_ctor_set(x_232, 3, x_228); +lean_ctor_set_uint8(x_232, sizeof(void*)*4, x_230); +x_233 = 0; +lean_ctor_set(x_1, 3, x_232); +lean_ctor_set(x_1, 2, x_224); +lean_ctor_set(x_1, 1, x_223); +lean_ctor_set(x_1, 0, x_231); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_233); +return x_1; +} +} +else +{ +uint8_t x_234; +lean_free_object(x_1); +x_234 = !lean_is_exclusive(x_194); +if (x_234 == 0) +{ +lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; uint8_t x_239; +x_235 = lean_ctor_get(x_194, 3); +lean_dec(x_235); +x_236 = lean_ctor_get(x_194, 2); +lean_dec(x_236); +x_237 = lean_ctor_get(x_194, 1); +lean_dec(x_237); +x_238 = lean_ctor_get(x_194, 0); +lean_dec(x_238); +x_239 = 1; +lean_ctor_set(x_194, 3, x_191); +lean_ctor_set(x_194, 2, x_35); +lean_ctor_set(x_194, 1, x_34); +lean_ctor_set(x_194, 0, x_33); +lean_ctor_set_uint8(x_194, sizeof(void*)*4, x_239); +return x_194; +} +else +{ +uint8_t x_240; lean_object* x_241; +lean_dec(x_194); +x_240 = 1; +x_241 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_241, 0, x_33); +lean_ctor_set(x_241, 1, x_34); +lean_ctor_set(x_241, 2, x_35); +lean_ctor_set(x_241, 3, x_191); +lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_240); +return x_241; +} +} +} +} +else +{ +uint8_t x_242; +x_242 = lean_ctor_get_uint8(x_193, sizeof(void*)*4); +if (x_242 == 0) +{ +uint8_t x_243; +x_243 = !lean_is_exclusive(x_191); +if (x_243 == 0) +{ +lean_object* x_244; uint8_t x_245; +x_244 = lean_ctor_get(x_191, 0); +lean_dec(x_244); +x_245 = !lean_is_exclusive(x_193); +if (x_245 == 0) +{ +lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; uint8_t x_250; uint8_t x_251; +x_246 = lean_ctor_get(x_193, 0); +x_247 = lean_ctor_get(x_193, 1); +x_248 = lean_ctor_get(x_193, 2); +x_249 = lean_ctor_get(x_193, 3); +x_250 = 1; +lean_ctor_set(x_193, 3, x_246); +lean_ctor_set(x_193, 2, x_35); +lean_ctor_set(x_193, 1, x_34); +lean_ctor_set(x_193, 0, x_33); +lean_ctor_set_uint8(x_193, sizeof(void*)*4, x_250); +lean_ctor_set(x_191, 0, x_249); +lean_ctor_set_uint8(x_191, sizeof(void*)*4, x_250); +x_251 = 0; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set(x_1, 2, x_248); +lean_ctor_set(x_1, 1, x_247); +lean_ctor_set(x_1, 0, x_193); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_251); +return x_1; +} +else +{ +lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; lean_object* x_257; uint8_t x_258; +x_252 = lean_ctor_get(x_193, 0); +x_253 = lean_ctor_get(x_193, 1); +x_254 = lean_ctor_get(x_193, 2); +x_255 = lean_ctor_get(x_193, 3); +lean_inc(x_255); +lean_inc(x_254); +lean_inc(x_253); +lean_inc(x_252); +lean_dec(x_193); +x_256 = 1; +x_257 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_257, 0, x_33); +lean_ctor_set(x_257, 1, x_34); +lean_ctor_set(x_257, 2, x_35); +lean_ctor_set(x_257, 3, x_252); +lean_ctor_set_uint8(x_257, sizeof(void*)*4, x_256); +lean_ctor_set(x_191, 0, x_255); +lean_ctor_set_uint8(x_191, sizeof(void*)*4, x_256); +x_258 = 0; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set(x_1, 2, x_254); +lean_ctor_set(x_1, 1, x_253); +lean_ctor_set(x_1, 0, x_257); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_258); +return x_1; +} +} +else +{ +lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; +x_259 = lean_ctor_get(x_191, 1); +x_260 = lean_ctor_get(x_191, 2); +x_261 = lean_ctor_get(x_191, 3); +lean_inc(x_261); +lean_inc(x_260); +lean_inc(x_259); +lean_dec(x_191); +x_262 = lean_ctor_get(x_193, 0); +lean_inc(x_262); +x_263 = lean_ctor_get(x_193, 1); +lean_inc(x_263); +x_264 = lean_ctor_get(x_193, 2); +lean_inc(x_264); +x_265 = lean_ctor_get(x_193, 3); +lean_inc(x_265); +if (lean_is_exclusive(x_193)) { + lean_ctor_release(x_193, 0); + lean_ctor_release(x_193, 1); + lean_ctor_release(x_193, 2); + lean_ctor_release(x_193, 3); + x_266 = x_193; +} else { + lean_dec_ref(x_193); + x_266 = lean_box(0); +} +x_267 = 1; +if (lean_is_scalar(x_266)) { + x_268 = lean_alloc_ctor(1, 4, 1); +} else { + x_268 = x_266; +} +lean_ctor_set(x_268, 0, x_33); +lean_ctor_set(x_268, 1, x_34); +lean_ctor_set(x_268, 2, x_35); +lean_ctor_set(x_268, 3, x_262); +lean_ctor_set_uint8(x_268, sizeof(void*)*4, x_267); +x_269 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_269, 0, x_265); +lean_ctor_set(x_269, 1, x_259); +lean_ctor_set(x_269, 2, x_260); +lean_ctor_set(x_269, 3, x_261); +lean_ctor_set_uint8(x_269, sizeof(void*)*4, x_267); +x_270 = 0; +lean_ctor_set(x_1, 3, x_269); +lean_ctor_set(x_1, 2, x_264); +lean_ctor_set(x_1, 1, x_263); +lean_ctor_set(x_1, 0, x_268); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_270); +return x_1; +} +} +else +{ +lean_object* x_271; +x_271 = lean_ctor_get(x_191, 3); +lean_inc(x_271); +if (lean_obj_tag(x_271) == 0) +{ +uint8_t x_272; +lean_free_object(x_1); +x_272 = !lean_is_exclusive(x_193); +if (x_272 == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; uint8_t x_277; +x_273 = lean_ctor_get(x_193, 3); +lean_dec(x_273); +x_274 = lean_ctor_get(x_193, 2); +lean_dec(x_274); +x_275 = lean_ctor_get(x_193, 1); +lean_dec(x_275); +x_276 = lean_ctor_get(x_193, 0); +lean_dec(x_276); +x_277 = 1; +lean_ctor_set(x_193, 3, x_191); +lean_ctor_set(x_193, 2, x_35); +lean_ctor_set(x_193, 1, x_34); +lean_ctor_set(x_193, 0, x_33); +lean_ctor_set_uint8(x_193, sizeof(void*)*4, x_277); +return x_193; +} +else +{ +uint8_t x_278; lean_object* x_279; +lean_dec(x_193); +x_278 = 1; +x_279 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_279, 0, x_33); +lean_ctor_set(x_279, 1, x_34); +lean_ctor_set(x_279, 2, x_35); +lean_ctor_set(x_279, 3, x_191); +lean_ctor_set_uint8(x_279, sizeof(void*)*4, x_278); +return x_279; +} +} +else +{ +uint8_t x_280; +x_280 = lean_ctor_get_uint8(x_271, sizeof(void*)*4); +if (x_280 == 0) +{ +uint8_t x_281; +lean_free_object(x_1); +x_281 = !lean_is_exclusive(x_191); +if (x_281 == 0) +{ +lean_object* x_282; lean_object* x_283; uint8_t x_284; +x_282 = lean_ctor_get(x_191, 3); +lean_dec(x_282); +x_283 = lean_ctor_get(x_191, 0); +lean_dec(x_283); +x_284 = !lean_is_exclusive(x_271); +if (x_284 == 0) +{ +lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; uint8_t x_289; uint8_t x_290; +x_285 = lean_ctor_get(x_271, 0); +x_286 = lean_ctor_get(x_271, 1); +x_287 = lean_ctor_get(x_271, 2); +x_288 = lean_ctor_get(x_271, 3); +x_289 = 1; +lean_inc(x_193); +lean_ctor_set(x_271, 3, x_193); +lean_ctor_set(x_271, 2, x_35); +lean_ctor_set(x_271, 1, x_34); +lean_ctor_set(x_271, 0, x_33); +x_290 = !lean_is_exclusive(x_193); +if (x_290 == 0) +{ +lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; uint8_t x_295; +x_291 = lean_ctor_get(x_193, 3); +lean_dec(x_291); +x_292 = lean_ctor_get(x_193, 2); +lean_dec(x_292); +x_293 = lean_ctor_get(x_193, 1); +lean_dec(x_293); +x_294 = lean_ctor_get(x_193, 0); +lean_dec(x_294); +lean_ctor_set_uint8(x_271, sizeof(void*)*4, x_289); +lean_ctor_set(x_193, 3, x_288); +lean_ctor_set(x_193, 2, x_287); +lean_ctor_set(x_193, 1, x_286); +lean_ctor_set(x_193, 0, x_285); +lean_ctor_set_uint8(x_193, sizeof(void*)*4, x_289); +x_295 = 0; +lean_ctor_set(x_191, 3, x_193); +lean_ctor_set(x_191, 0, x_271); +lean_ctor_set_uint8(x_191, sizeof(void*)*4, x_295); +return x_191; +} +else +{ +lean_object* x_296; uint8_t x_297; +lean_dec(x_193); +lean_ctor_set_uint8(x_271, sizeof(void*)*4, x_289); +x_296 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_296, 0, x_285); +lean_ctor_set(x_296, 1, x_286); +lean_ctor_set(x_296, 2, x_287); +lean_ctor_set(x_296, 3, x_288); +lean_ctor_set_uint8(x_296, sizeof(void*)*4, x_289); +x_297 = 0; +lean_ctor_set(x_191, 3, x_296); +lean_ctor_set(x_191, 0, x_271); +lean_ctor_set_uint8(x_191, sizeof(void*)*4, x_297); +return x_191; +} +} +else +{ +lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; uint8_t x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; uint8_t x_306; +x_298 = lean_ctor_get(x_271, 0); +x_299 = lean_ctor_get(x_271, 1); +x_300 = lean_ctor_get(x_271, 2); +x_301 = lean_ctor_get(x_271, 3); +lean_inc(x_301); +lean_inc(x_300); +lean_inc(x_299); +lean_inc(x_298); +lean_dec(x_271); +x_302 = 1; +lean_inc(x_193); +x_303 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_303, 0, x_33); +lean_ctor_set(x_303, 1, x_34); +lean_ctor_set(x_303, 2, x_35); +lean_ctor_set(x_303, 3, x_193); +if (lean_is_exclusive(x_193)) { + lean_ctor_release(x_193, 0); + lean_ctor_release(x_193, 1); + lean_ctor_release(x_193, 2); + lean_ctor_release(x_193, 3); + x_304 = x_193; +} else { + lean_dec_ref(x_193); + x_304 = lean_box(0); +} +lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_302); +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 4, 1); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_298); +lean_ctor_set(x_305, 1, x_299); +lean_ctor_set(x_305, 2, x_300); +lean_ctor_set(x_305, 3, x_301); +lean_ctor_set_uint8(x_305, sizeof(void*)*4, x_302); +x_306 = 0; +lean_ctor_set(x_191, 3, x_305); +lean_ctor_set(x_191, 0, x_303); +lean_ctor_set_uint8(x_191, sizeof(void*)*4, x_306); +return x_191; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; uint8_t x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; uint8_t x_318; lean_object* x_319; +x_307 = lean_ctor_get(x_191, 1); +x_308 = lean_ctor_get(x_191, 2); +lean_inc(x_308); +lean_inc(x_307); +lean_dec(x_191); +x_309 = lean_ctor_get(x_271, 0); +lean_inc(x_309); +x_310 = lean_ctor_get(x_271, 1); +lean_inc(x_310); +x_311 = lean_ctor_get(x_271, 2); +lean_inc(x_311); +x_312 = lean_ctor_get(x_271, 3); +lean_inc(x_312); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + lean_ctor_release(x_271, 2); + lean_ctor_release(x_271, 3); + x_313 = x_271; +} else { + lean_dec_ref(x_271); + x_313 = lean_box(0); +} +x_314 = 1; +lean_inc(x_193); +if (lean_is_scalar(x_313)) { + x_315 = lean_alloc_ctor(1, 4, 1); +} else { + x_315 = x_313; +} +lean_ctor_set(x_315, 0, x_33); +lean_ctor_set(x_315, 1, x_34); +lean_ctor_set(x_315, 2, x_35); +lean_ctor_set(x_315, 3, x_193); +if (lean_is_exclusive(x_193)) { + lean_ctor_release(x_193, 0); + lean_ctor_release(x_193, 1); + lean_ctor_release(x_193, 2); + lean_ctor_release(x_193, 3); + x_316 = x_193; +} else { + lean_dec_ref(x_193); + x_316 = lean_box(0); +} +lean_ctor_set_uint8(x_315, sizeof(void*)*4, x_314); +if (lean_is_scalar(x_316)) { + x_317 = lean_alloc_ctor(1, 4, 1); +} else { + x_317 = x_316; +} +lean_ctor_set(x_317, 0, x_309); +lean_ctor_set(x_317, 1, x_310); +lean_ctor_set(x_317, 2, x_311); +lean_ctor_set(x_317, 3, x_312); +lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_314); +x_318 = 0; +x_319 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_319, 0, x_315); +lean_ctor_set(x_319, 1, x_307); +lean_ctor_set(x_319, 2, x_308); +lean_ctor_set(x_319, 3, x_317); +lean_ctor_set_uint8(x_319, sizeof(void*)*4, x_318); +return x_319; +} +} +else +{ +uint8_t x_320; +x_320 = !lean_is_exclusive(x_191); +if (x_320 == 0) +{ +lean_object* x_321; lean_object* x_322; uint8_t x_323; +x_321 = lean_ctor_get(x_191, 3); +lean_dec(x_321); +x_322 = lean_ctor_get(x_191, 0); +lean_dec(x_322); +x_323 = !lean_is_exclusive(x_193); +if (x_323 == 0) +{ +uint8_t x_324; +lean_ctor_set_uint8(x_193, sizeof(void*)*4, x_280); +x_324 = 1; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_324); +return x_1; +} +else +{ +lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; uint8_t x_330; +x_325 = lean_ctor_get(x_193, 0); +x_326 = lean_ctor_get(x_193, 1); +x_327 = lean_ctor_get(x_193, 2); +x_328 = lean_ctor_get(x_193, 3); +lean_inc(x_328); +lean_inc(x_327); +lean_inc(x_326); +lean_inc(x_325); +lean_dec(x_193); +x_329 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_329, 0, x_325); +lean_ctor_set(x_329, 1, x_326); +lean_ctor_set(x_329, 2, x_327); +lean_ctor_set(x_329, 3, x_328); +lean_ctor_set_uint8(x_329, sizeof(void*)*4, x_280); +lean_ctor_set(x_191, 0, x_329); +x_330 = 1; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_330); +return x_1; +} +} +else +{ +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; uint8_t x_340; +x_331 = lean_ctor_get(x_191, 1); +x_332 = lean_ctor_get(x_191, 2); +lean_inc(x_332); +lean_inc(x_331); +lean_dec(x_191); +x_333 = lean_ctor_get(x_193, 0); +lean_inc(x_333); +x_334 = lean_ctor_get(x_193, 1); +lean_inc(x_334); +x_335 = lean_ctor_get(x_193, 2); +lean_inc(x_335); +x_336 = lean_ctor_get(x_193, 3); +lean_inc(x_336); +if (lean_is_exclusive(x_193)) { + lean_ctor_release(x_193, 0); + lean_ctor_release(x_193, 1); + lean_ctor_release(x_193, 2); + lean_ctor_release(x_193, 3); + x_337 = x_193; +} else { + lean_dec_ref(x_193); + x_337 = lean_box(0); +} +if (lean_is_scalar(x_337)) { + x_338 = lean_alloc_ctor(1, 4, 1); +} else { + x_338 = x_337; +} +lean_ctor_set(x_338, 0, x_333); +lean_ctor_set(x_338, 1, x_334); +lean_ctor_set(x_338, 2, x_335); +lean_ctor_set(x_338, 3, x_336); +lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_280); +x_339 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_339, 0, x_338); +lean_ctor_set(x_339, 1, x_331); +lean_ctor_set(x_339, 2, x_332); +lean_ctor_set(x_339, 3, x_271); +lean_ctor_set_uint8(x_339, sizeof(void*)*4, x_192); +x_340 = 1; +lean_ctor_set(x_1, 3, x_339); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_340); +return x_1; +} +} +} +} +} +} +else +{ +uint8_t x_341; +x_341 = 1; +lean_ctor_set(x_1, 3, x_191); +lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_341); +return x_1; +} +} +} +} +else +{ +lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; uint8_t x_346; +x_342 = lean_ctor_get(x_1, 0); +x_343 = lean_ctor_get(x_1, 1); +x_344 = lean_ctor_get(x_1, 2); +x_345 = lean_ctor_get(x_1, 3); +lean_inc(x_345); +lean_inc(x_344); +lean_inc(x_343); +lean_inc(x_342); +lean_dec(x_1); +x_346 = l_Lake_BuildKey_quickCmp(x_2, x_343); +switch (x_346) { +case 0: +{ +lean_object* x_347; uint8_t x_348; +x_347 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_342, x_2, x_3); +x_348 = lean_ctor_get_uint8(x_347, sizeof(void*)*4); +if (x_348 == 0) +{ +lean_object* x_349; +x_349 = lean_ctor_get(x_347, 0); +lean_inc(x_349); +if (lean_obj_tag(x_349) == 0) +{ +lean_object* x_350; +x_350 = lean_ctor_get(x_347, 3); +lean_inc(x_350); +if (lean_obj_tag(x_350) == 0) +{ +lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; uint8_t x_355; lean_object* x_356; +x_351 = lean_ctor_get(x_347, 1); +lean_inc(x_351); +x_352 = lean_ctor_get(x_347, 2); +lean_inc(x_352); +if (lean_is_exclusive(x_347)) { + lean_ctor_release(x_347, 0); + lean_ctor_release(x_347, 1); + lean_ctor_release(x_347, 2); + lean_ctor_release(x_347, 3); + x_353 = x_347; +} else { + lean_dec_ref(x_347); + x_353 = lean_box(0); +} +if (lean_is_scalar(x_353)) { + x_354 = lean_alloc_ctor(1, 4, 1); +} else { + x_354 = x_353; +} +lean_ctor_set(x_354, 0, x_350); +lean_ctor_set(x_354, 1, x_351); +lean_ctor_set(x_354, 2, x_352); +lean_ctor_set(x_354, 3, x_350); +lean_ctor_set_uint8(x_354, sizeof(void*)*4, x_348); +x_355 = 1; +x_356 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_356, 0, x_354); +lean_ctor_set(x_356, 1, x_343); +lean_ctor_set(x_356, 2, x_344); +lean_ctor_set(x_356, 3, x_345); +lean_ctor_set_uint8(x_356, sizeof(void*)*4, x_355); +return x_356; +} +else +{ +uint8_t x_357; +x_357 = lean_ctor_get_uint8(x_350, sizeof(void*)*4); +if (x_357 == 0) +{ +lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; uint8_t x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; lean_object* x_370; +x_358 = lean_ctor_get(x_347, 1); +lean_inc(x_358); +x_359 = lean_ctor_get(x_347, 2); +lean_inc(x_359); +if (lean_is_exclusive(x_347)) { + lean_ctor_release(x_347, 0); + lean_ctor_release(x_347, 1); + lean_ctor_release(x_347, 2); + lean_ctor_release(x_347, 3); + x_360 = x_347; +} else { + lean_dec_ref(x_347); + x_360 = lean_box(0); +} +x_361 = lean_ctor_get(x_350, 0); +lean_inc(x_361); +x_362 = lean_ctor_get(x_350, 1); +lean_inc(x_362); +x_363 = lean_ctor_get(x_350, 2); +lean_inc(x_363); +x_364 = lean_ctor_get(x_350, 3); +lean_inc(x_364); +if (lean_is_exclusive(x_350)) { + lean_ctor_release(x_350, 0); + lean_ctor_release(x_350, 1); + lean_ctor_release(x_350, 2); + lean_ctor_release(x_350, 3); + x_365 = x_350; +} else { + lean_dec_ref(x_350); + x_365 = lean_box(0); +} +x_366 = 1; +if (lean_is_scalar(x_365)) { + x_367 = lean_alloc_ctor(1, 4, 1); +} else { + x_367 = x_365; +} +lean_ctor_set(x_367, 0, x_349); +lean_ctor_set(x_367, 1, x_358); +lean_ctor_set(x_367, 2, x_359); +lean_ctor_set(x_367, 3, x_361); +lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_366); +if (lean_is_scalar(x_360)) { + x_368 = lean_alloc_ctor(1, 4, 1); +} else { + x_368 = x_360; +} +lean_ctor_set(x_368, 0, x_364); +lean_ctor_set(x_368, 1, x_343); +lean_ctor_set(x_368, 2, x_344); +lean_ctor_set(x_368, 3, x_345); +lean_ctor_set_uint8(x_368, sizeof(void*)*4, x_366); +x_369 = 0; +x_370 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_370, 0, x_367); +lean_ctor_set(x_370, 1, x_362); +lean_ctor_set(x_370, 2, x_363); +lean_ctor_set(x_370, 3, x_368); +lean_ctor_set_uint8(x_370, sizeof(void*)*4, x_369); +return x_370; +} +else +{ +lean_object* x_371; uint8_t x_372; lean_object* x_373; +if (lean_is_exclusive(x_350)) { + lean_ctor_release(x_350, 0); + lean_ctor_release(x_350, 1); + lean_ctor_release(x_350, 2); + lean_ctor_release(x_350, 3); + x_371 = x_350; +} else { + lean_dec_ref(x_350); + x_371 = lean_box(0); +} +x_372 = 1; +if (lean_is_scalar(x_371)) { + x_373 = lean_alloc_ctor(1, 4, 1); +} else { + x_373 = x_371; +} +lean_ctor_set(x_373, 0, x_347); +lean_ctor_set(x_373, 1, x_343); +lean_ctor_set(x_373, 2, x_344); +lean_ctor_set(x_373, 3, x_345); +lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372); +return x_373; +} +} +} +else +{ +uint8_t x_374; +x_374 = lean_ctor_get_uint8(x_349, sizeof(void*)*4); +if (x_374 == 0) +{ +lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; uint8_t x_384; lean_object* x_385; lean_object* x_386; uint8_t x_387; lean_object* x_388; +x_375 = lean_ctor_get(x_347, 1); +lean_inc(x_375); +x_376 = lean_ctor_get(x_347, 2); +lean_inc(x_376); +x_377 = lean_ctor_get(x_347, 3); +lean_inc(x_377); +if (lean_is_exclusive(x_347)) { + lean_ctor_release(x_347, 0); + lean_ctor_release(x_347, 1); + lean_ctor_release(x_347, 2); + lean_ctor_release(x_347, 3); + x_378 = x_347; +} else { + lean_dec_ref(x_347); + x_378 = lean_box(0); +} +x_379 = lean_ctor_get(x_349, 0); +lean_inc(x_379); +x_380 = lean_ctor_get(x_349, 1); +lean_inc(x_380); +x_381 = lean_ctor_get(x_349, 2); +lean_inc(x_381); +x_382 = lean_ctor_get(x_349, 3); +lean_inc(x_382); +if (lean_is_exclusive(x_349)) { + lean_ctor_release(x_349, 0); + lean_ctor_release(x_349, 1); + lean_ctor_release(x_349, 2); + lean_ctor_release(x_349, 3); + x_383 = x_349; +} else { + lean_dec_ref(x_349); + x_383 = lean_box(0); +} +x_384 = 1; +if (lean_is_scalar(x_383)) { + x_385 = lean_alloc_ctor(1, 4, 1); +} else { + x_385 = x_383; +} +lean_ctor_set(x_385, 0, x_379); +lean_ctor_set(x_385, 1, x_380); +lean_ctor_set(x_385, 2, x_381); +lean_ctor_set(x_385, 3, x_382); +lean_ctor_set_uint8(x_385, sizeof(void*)*4, x_384); +if (lean_is_scalar(x_378)) { + x_386 = lean_alloc_ctor(1, 4, 1); +} else { + x_386 = x_378; +} +lean_ctor_set(x_386, 0, x_377); +lean_ctor_set(x_386, 1, x_343); +lean_ctor_set(x_386, 2, x_344); +lean_ctor_set(x_386, 3, x_345); +lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_384); +x_387 = 0; +x_388 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_388, 0, x_385); +lean_ctor_set(x_388, 1, x_375); +lean_ctor_set(x_388, 2, x_376); +lean_ctor_set(x_388, 3, x_386); +lean_ctor_set_uint8(x_388, sizeof(void*)*4, x_387); +return x_388; +} +else +{ +lean_object* x_389; +x_389 = lean_ctor_get(x_347, 3); +lean_inc(x_389); +if (lean_obj_tag(x_389) == 0) +{ +lean_object* x_390; uint8_t x_391; lean_object* x_392; +if (lean_is_exclusive(x_349)) { + lean_ctor_release(x_349, 0); + lean_ctor_release(x_349, 1); + lean_ctor_release(x_349, 2); + lean_ctor_release(x_349, 3); + x_390 = x_349; +} else { + lean_dec_ref(x_349); + x_390 = lean_box(0); +} +x_391 = 1; +if (lean_is_scalar(x_390)) { + x_392 = lean_alloc_ctor(1, 4, 1); +} else { + x_392 = x_390; +} +lean_ctor_set(x_392, 0, x_347); +lean_ctor_set(x_392, 1, x_343); +lean_ctor_set(x_392, 2, x_344); +lean_ctor_set(x_392, 3, x_345); +lean_ctor_set_uint8(x_392, sizeof(void*)*4, x_391); +return x_392; +} +else +{ +uint8_t x_393; +x_393 = lean_ctor_get_uint8(x_389, sizeof(void*)*4); +if (x_393 == 0) +{ +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; uint8_t x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; +x_394 = lean_ctor_get(x_347, 1); +lean_inc(x_394); +x_395 = lean_ctor_get(x_347, 2); +lean_inc(x_395); +if (lean_is_exclusive(x_347)) { + lean_ctor_release(x_347, 0); + lean_ctor_release(x_347, 1); + lean_ctor_release(x_347, 2); + lean_ctor_release(x_347, 3); + x_396 = x_347; +} else { + lean_dec_ref(x_347); + x_396 = lean_box(0); +} +x_397 = lean_ctor_get(x_389, 0); +lean_inc(x_397); +x_398 = lean_ctor_get(x_389, 1); +lean_inc(x_398); +x_399 = lean_ctor_get(x_389, 2); +lean_inc(x_399); +x_400 = lean_ctor_get(x_389, 3); +lean_inc(x_400); +if (lean_is_exclusive(x_389)) { + lean_ctor_release(x_389, 0); + lean_ctor_release(x_389, 1); + lean_ctor_release(x_389, 2); + lean_ctor_release(x_389, 3); + x_401 = x_389; +} else { + lean_dec_ref(x_389); + x_401 = lean_box(0); +} +x_402 = 1; +lean_inc(x_349); +if (lean_is_scalar(x_401)) { + x_403 = lean_alloc_ctor(1, 4, 1); +} else { + x_403 = x_401; +} +lean_ctor_set(x_403, 0, x_349); +lean_ctor_set(x_403, 1, x_394); +lean_ctor_set(x_403, 2, x_395); +lean_ctor_set(x_403, 3, x_397); +if (lean_is_exclusive(x_349)) { + lean_ctor_release(x_349, 0); + lean_ctor_release(x_349, 1); + lean_ctor_release(x_349, 2); + lean_ctor_release(x_349, 3); + x_404 = x_349; +} else { + lean_dec_ref(x_349); + x_404 = lean_box(0); +} +lean_ctor_set_uint8(x_403, sizeof(void*)*4, x_402); +if (lean_is_scalar(x_404)) { + x_405 = lean_alloc_ctor(1, 4, 1); +} else { + x_405 = x_404; +} +lean_ctor_set(x_405, 0, x_400); +lean_ctor_set(x_405, 1, x_343); +lean_ctor_set(x_405, 2, x_344); +lean_ctor_set(x_405, 3, x_345); +lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_402); +x_406 = 0; +if (lean_is_scalar(x_396)) { + x_407 = lean_alloc_ctor(1, 4, 1); +} else { + x_407 = x_396; +} +lean_ctor_set(x_407, 0, x_403); +lean_ctor_set(x_407, 1, x_398); +lean_ctor_set(x_407, 2, x_399); +lean_ctor_set(x_407, 3, x_405); +lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406); +return x_407; +} +else +{ +lean_object* x_408; lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; +x_408 = lean_ctor_get(x_347, 1); +lean_inc(x_408); +x_409 = lean_ctor_get(x_347, 2); +lean_inc(x_409); +if (lean_is_exclusive(x_347)) { + lean_ctor_release(x_347, 0); + lean_ctor_release(x_347, 1); + lean_ctor_release(x_347, 2); + lean_ctor_release(x_347, 3); + x_410 = x_347; +} else { + lean_dec_ref(x_347); + x_410 = lean_box(0); +} +x_411 = lean_ctor_get(x_349, 0); +lean_inc(x_411); +x_412 = lean_ctor_get(x_349, 1); +lean_inc(x_412); +x_413 = lean_ctor_get(x_349, 2); +lean_inc(x_413); +x_414 = lean_ctor_get(x_349, 3); +lean_inc(x_414); +if (lean_is_exclusive(x_349)) { + lean_ctor_release(x_349, 0); + lean_ctor_release(x_349, 1); + lean_ctor_release(x_349, 2); + lean_ctor_release(x_349, 3); + x_415 = x_349; +} else { + lean_dec_ref(x_349); + x_415 = lean_box(0); +} +if (lean_is_scalar(x_415)) { + x_416 = lean_alloc_ctor(1, 4, 1); +} else { + x_416 = x_415; +} +lean_ctor_set(x_416, 0, x_411); +lean_ctor_set(x_416, 1, x_412); +lean_ctor_set(x_416, 2, x_413); +lean_ctor_set(x_416, 3, x_414); +lean_ctor_set_uint8(x_416, sizeof(void*)*4, x_393); +if (lean_is_scalar(x_410)) { + x_417 = lean_alloc_ctor(1, 4, 1); +} else { + x_417 = x_410; +} +lean_ctor_set(x_417, 0, x_416); +lean_ctor_set(x_417, 1, x_408); +lean_ctor_set(x_417, 2, x_409); +lean_ctor_set(x_417, 3, x_389); +lean_ctor_set_uint8(x_417, sizeof(void*)*4, x_348); +x_418 = 1; +x_419 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_419, 0, x_417); +lean_ctor_set(x_419, 1, x_343); +lean_ctor_set(x_419, 2, x_344); +lean_ctor_set(x_419, 3, x_345); +lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418); +return x_419; +} +} +} +} +} +else +{ +uint8_t x_420; lean_object* x_421; +x_420 = 1; +x_421 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_421, 0, x_347); +lean_ctor_set(x_421, 1, x_343); +lean_ctor_set(x_421, 2, x_344); +lean_ctor_set(x_421, 3, x_345); +lean_ctor_set_uint8(x_421, sizeof(void*)*4, x_420); +return x_421; +} +} +case 1: +{ +uint8_t x_422; lean_object* x_423; +lean_dec(x_344); +lean_dec(x_343); +x_422 = 1; +x_423 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_423, 0, x_342); +lean_ctor_set(x_423, 1, x_2); +lean_ctor_set(x_423, 2, x_3); +lean_ctor_set(x_423, 3, x_345); +lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422); +return x_423; +} +default: +{ +lean_object* x_424; uint8_t x_425; +x_424 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_345, x_2, x_3); +x_425 = lean_ctor_get_uint8(x_424, sizeof(void*)*4); +if (x_425 == 0) +{ +lean_object* x_426; +x_426 = lean_ctor_get(x_424, 0); +lean_inc(x_426); +if (lean_obj_tag(x_426) == 0) +{ +lean_object* x_427; +x_427 = lean_ctor_get(x_424, 3); +lean_inc(x_427); +if (lean_obj_tag(x_427) == 0) +{ +lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; uint8_t x_432; lean_object* x_433; +x_428 = lean_ctor_get(x_424, 1); +lean_inc(x_428); +x_429 = lean_ctor_get(x_424, 2); +lean_inc(x_429); +if (lean_is_exclusive(x_424)) { + lean_ctor_release(x_424, 0); + lean_ctor_release(x_424, 1); + lean_ctor_release(x_424, 2); + lean_ctor_release(x_424, 3); + x_430 = x_424; +} else { + lean_dec_ref(x_424); + x_430 = lean_box(0); +} +if (lean_is_scalar(x_430)) { + x_431 = lean_alloc_ctor(1, 4, 1); +} else { + x_431 = x_430; +} +lean_ctor_set(x_431, 0, x_427); +lean_ctor_set(x_431, 1, x_428); +lean_ctor_set(x_431, 2, x_429); +lean_ctor_set(x_431, 3, x_427); +lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_425); +x_432 = 1; +x_433 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_433, 0, x_342); +lean_ctor_set(x_433, 1, x_343); +lean_ctor_set(x_433, 2, x_344); +lean_ctor_set(x_433, 3, x_431); +lean_ctor_set_uint8(x_433, sizeof(void*)*4, x_432); +return x_433; +} +else +{ +uint8_t x_434; +x_434 = lean_ctor_get_uint8(x_427, sizeof(void*)*4); +if (x_434 == 0) +{ +lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; lean_object* x_442; uint8_t x_443; lean_object* x_444; lean_object* x_445; uint8_t x_446; lean_object* x_447; +x_435 = lean_ctor_get(x_424, 1); +lean_inc(x_435); +x_436 = lean_ctor_get(x_424, 2); +lean_inc(x_436); +if (lean_is_exclusive(x_424)) { + lean_ctor_release(x_424, 0); + lean_ctor_release(x_424, 1); + lean_ctor_release(x_424, 2); + lean_ctor_release(x_424, 3); + x_437 = x_424; +} else { + lean_dec_ref(x_424); + x_437 = lean_box(0); +} +x_438 = lean_ctor_get(x_427, 0); +lean_inc(x_438); +x_439 = lean_ctor_get(x_427, 1); +lean_inc(x_439); +x_440 = lean_ctor_get(x_427, 2); +lean_inc(x_440); +x_441 = lean_ctor_get(x_427, 3); +lean_inc(x_441); +if (lean_is_exclusive(x_427)) { + lean_ctor_release(x_427, 0); + lean_ctor_release(x_427, 1); + lean_ctor_release(x_427, 2); + lean_ctor_release(x_427, 3); + x_442 = x_427; +} else { + lean_dec_ref(x_427); + x_442 = lean_box(0); +} +x_443 = 1; +if (lean_is_scalar(x_442)) { + x_444 = lean_alloc_ctor(1, 4, 1); +} else { + x_444 = x_442; +} +lean_ctor_set(x_444, 0, x_342); +lean_ctor_set(x_444, 1, x_343); +lean_ctor_set(x_444, 2, x_344); +lean_ctor_set(x_444, 3, x_426); +lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_443); +if (lean_is_scalar(x_437)) { + x_445 = lean_alloc_ctor(1, 4, 1); +} else { + x_445 = x_437; +} +lean_ctor_set(x_445, 0, x_438); +lean_ctor_set(x_445, 1, x_439); +lean_ctor_set(x_445, 2, x_440); +lean_ctor_set(x_445, 3, x_441); +lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_443); +x_446 = 0; +x_447 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_447, 0, x_444); +lean_ctor_set(x_447, 1, x_435); +lean_ctor_set(x_447, 2, x_436); +lean_ctor_set(x_447, 3, x_445); +lean_ctor_set_uint8(x_447, sizeof(void*)*4, x_446); +return x_447; +} +else +{ +lean_object* x_448; uint8_t x_449; lean_object* x_450; +if (lean_is_exclusive(x_427)) { + lean_ctor_release(x_427, 0); + lean_ctor_release(x_427, 1); + lean_ctor_release(x_427, 2); + lean_ctor_release(x_427, 3); + x_448 = x_427; +} else { + lean_dec_ref(x_427); + x_448 = lean_box(0); +} +x_449 = 1; +if (lean_is_scalar(x_448)) { + x_450 = lean_alloc_ctor(1, 4, 1); +} else { + x_450 = x_448; +} +lean_ctor_set(x_450, 0, x_342); +lean_ctor_set(x_450, 1, x_343); +lean_ctor_set(x_450, 2, x_344); +lean_ctor_set(x_450, 3, x_424); +lean_ctor_set_uint8(x_450, sizeof(void*)*4, x_449); +return x_450; +} +} +} +else +{ +uint8_t x_451; +x_451 = lean_ctor_get_uint8(x_426, sizeof(void*)*4); +if (x_451 == 0) +{ +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; uint8_t x_461; lean_object* x_462; lean_object* x_463; uint8_t x_464; lean_object* x_465; +x_452 = lean_ctor_get(x_424, 1); +lean_inc(x_452); +x_453 = lean_ctor_get(x_424, 2); +lean_inc(x_453); +x_454 = lean_ctor_get(x_424, 3); +lean_inc(x_454); +if (lean_is_exclusive(x_424)) { + lean_ctor_release(x_424, 0); + lean_ctor_release(x_424, 1); + lean_ctor_release(x_424, 2); + lean_ctor_release(x_424, 3); + x_455 = x_424; +} else { + lean_dec_ref(x_424); + x_455 = lean_box(0); +} +x_456 = lean_ctor_get(x_426, 0); +lean_inc(x_456); +x_457 = lean_ctor_get(x_426, 1); +lean_inc(x_457); +x_458 = lean_ctor_get(x_426, 2); +lean_inc(x_458); +x_459 = lean_ctor_get(x_426, 3); +lean_inc(x_459); +if (lean_is_exclusive(x_426)) { + lean_ctor_release(x_426, 0); + lean_ctor_release(x_426, 1); + lean_ctor_release(x_426, 2); + lean_ctor_release(x_426, 3); + x_460 = x_426; +} else { + lean_dec_ref(x_426); + x_460 = lean_box(0); +} +x_461 = 1; +if (lean_is_scalar(x_460)) { + x_462 = lean_alloc_ctor(1, 4, 1); +} else { + x_462 = x_460; +} +lean_ctor_set(x_462, 0, x_342); +lean_ctor_set(x_462, 1, x_343); +lean_ctor_set(x_462, 2, x_344); +lean_ctor_set(x_462, 3, x_456); +lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461); +if (lean_is_scalar(x_455)) { + x_463 = lean_alloc_ctor(1, 4, 1); +} else { + x_463 = x_455; +} +lean_ctor_set(x_463, 0, x_459); +lean_ctor_set(x_463, 1, x_452); +lean_ctor_set(x_463, 2, x_453); +lean_ctor_set(x_463, 3, x_454); +lean_ctor_set_uint8(x_463, sizeof(void*)*4, x_461); +x_464 = 0; +x_465 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_465, 0, x_462); +lean_ctor_set(x_465, 1, x_457); +lean_ctor_set(x_465, 2, x_458); +lean_ctor_set(x_465, 3, x_463); +lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_464); +return x_465; +} +else +{ +lean_object* x_466; +x_466 = lean_ctor_get(x_424, 3); +lean_inc(x_466); +if (lean_obj_tag(x_466) == 0) +{ +lean_object* x_467; uint8_t x_468; lean_object* x_469; +if (lean_is_exclusive(x_426)) { + lean_ctor_release(x_426, 0); + lean_ctor_release(x_426, 1); + lean_ctor_release(x_426, 2); + lean_ctor_release(x_426, 3); + x_467 = x_426; +} else { + lean_dec_ref(x_426); + x_467 = lean_box(0); +} +x_468 = 1; +if (lean_is_scalar(x_467)) { + x_469 = lean_alloc_ctor(1, 4, 1); +} else { + x_469 = x_467; +} +lean_ctor_set(x_469, 0, x_342); +lean_ctor_set(x_469, 1, x_343); +lean_ctor_set(x_469, 2, x_344); +lean_ctor_set(x_469, 3, x_424); +lean_ctor_set_uint8(x_469, sizeof(void*)*4, x_468); +return x_469; +} +else +{ +uint8_t x_470; +x_470 = lean_ctor_get_uint8(x_466, sizeof(void*)*4); +if (x_470 == 0) +{ +lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; uint8_t x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; uint8_t x_483; lean_object* x_484; +x_471 = lean_ctor_get(x_424, 1); +lean_inc(x_471); +x_472 = lean_ctor_get(x_424, 2); +lean_inc(x_472); +if (lean_is_exclusive(x_424)) { + lean_ctor_release(x_424, 0); + lean_ctor_release(x_424, 1); + lean_ctor_release(x_424, 2); + lean_ctor_release(x_424, 3); + x_473 = x_424; +} else { + lean_dec_ref(x_424); + x_473 = lean_box(0); +} +x_474 = lean_ctor_get(x_466, 0); +lean_inc(x_474); +x_475 = lean_ctor_get(x_466, 1); +lean_inc(x_475); +x_476 = lean_ctor_get(x_466, 2); +lean_inc(x_476); +x_477 = lean_ctor_get(x_466, 3); +lean_inc(x_477); +if (lean_is_exclusive(x_466)) { + lean_ctor_release(x_466, 0); + lean_ctor_release(x_466, 1); + lean_ctor_release(x_466, 2); + lean_ctor_release(x_466, 3); + x_478 = x_466; +} else { + lean_dec_ref(x_466); + x_478 = lean_box(0); +} +x_479 = 1; +lean_inc(x_426); +if (lean_is_scalar(x_478)) { + x_480 = lean_alloc_ctor(1, 4, 1); +} else { + x_480 = x_478; +} +lean_ctor_set(x_480, 0, x_342); +lean_ctor_set(x_480, 1, x_343); +lean_ctor_set(x_480, 2, x_344); +lean_ctor_set(x_480, 3, x_426); +if (lean_is_exclusive(x_426)) { + lean_ctor_release(x_426, 0); + lean_ctor_release(x_426, 1); + lean_ctor_release(x_426, 2); + lean_ctor_release(x_426, 3); + x_481 = x_426; +} else { + lean_dec_ref(x_426); + x_481 = lean_box(0); +} +lean_ctor_set_uint8(x_480, sizeof(void*)*4, x_479); +if (lean_is_scalar(x_481)) { + x_482 = lean_alloc_ctor(1, 4, 1); +} else { + x_482 = x_481; +} +lean_ctor_set(x_482, 0, x_474); +lean_ctor_set(x_482, 1, x_475); +lean_ctor_set(x_482, 2, x_476); +lean_ctor_set(x_482, 3, x_477); +lean_ctor_set_uint8(x_482, sizeof(void*)*4, x_479); +x_483 = 0; +if (lean_is_scalar(x_473)) { + x_484 = lean_alloc_ctor(1, 4, 1); +} else { + x_484 = x_473; +} +lean_ctor_set(x_484, 0, x_480); +lean_ctor_set(x_484, 1, x_471); +lean_ctor_set(x_484, 2, x_472); +lean_ctor_set(x_484, 3, x_482); +lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_483); +return x_484; +} +else +{ +lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; uint8_t x_495; lean_object* x_496; +x_485 = lean_ctor_get(x_424, 1); +lean_inc(x_485); +x_486 = lean_ctor_get(x_424, 2); +lean_inc(x_486); +if (lean_is_exclusive(x_424)) { + lean_ctor_release(x_424, 0); + lean_ctor_release(x_424, 1); + lean_ctor_release(x_424, 2); + lean_ctor_release(x_424, 3); + x_487 = x_424; +} else { + lean_dec_ref(x_424); + x_487 = lean_box(0); +} +x_488 = lean_ctor_get(x_426, 0); +lean_inc(x_488); +x_489 = lean_ctor_get(x_426, 1); +lean_inc(x_489); +x_490 = lean_ctor_get(x_426, 2); +lean_inc(x_490); +x_491 = lean_ctor_get(x_426, 3); +lean_inc(x_491); +if (lean_is_exclusive(x_426)) { + lean_ctor_release(x_426, 0); + lean_ctor_release(x_426, 1); + lean_ctor_release(x_426, 2); + lean_ctor_release(x_426, 3); + x_492 = x_426; +} else { + lean_dec_ref(x_426); + x_492 = lean_box(0); +} +if (lean_is_scalar(x_492)) { + x_493 = lean_alloc_ctor(1, 4, 1); +} else { + x_493 = x_492; +} +lean_ctor_set(x_493, 0, x_488); +lean_ctor_set(x_493, 1, x_489); +lean_ctor_set(x_493, 2, x_490); +lean_ctor_set(x_493, 3, x_491); +lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_470); +if (lean_is_scalar(x_487)) { + x_494 = lean_alloc_ctor(1, 4, 1); +} else { + x_494 = x_487; +} +lean_ctor_set(x_494, 0, x_493); +lean_ctor_set(x_494, 1, x_485); +lean_ctor_set(x_494, 2, x_486); +lean_ctor_set(x_494, 3, x_466); +lean_ctor_set_uint8(x_494, sizeof(void*)*4, x_425); +x_495 = 1; +x_496 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_496, 0, x_342); +lean_ctor_set(x_496, 1, x_343); +lean_ctor_set(x_496, 2, x_344); +lean_ctor_set(x_496, 3, x_494); +lean_ctor_set_uint8(x_496, sizeof(void*)*4, x_495); +return x_496; +} +} +} +} +} +else +{ +uint8_t x_497; lean_object* x_498; +x_497 = 1; +x_498 = lean_alloc_ctor(1, 4, 1); +lean_ctor_set(x_498, 0, x_342); +lean_ctor_set(x_498, 1, x_343); +lean_ctor_set(x_498, 2, x_344); +lean_ctor_set(x_498, 3, x_424); +lean_ctor_set_uint8(x_498, sizeof(void*)*4, x_497); +return x_498; +} +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_insert___at_Lake_FetchM_run___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = l_Lean_RBNode_isRed___rarg(x_1); +if (x_4 == 0) +{ +lean_object* x_5; +x_5 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_1, x_2, x_3); +return x_5; +} +else +{ +lean_object* x_6; lean_object* x_7; +x_6 = l_Lean_RBNode_ins___at_Lake_FetchM_run___spec__4(x_1, x_2, x_3); +x_7 = l_Lean_RBNode_setBlack___rarg(x_6); +return x_7; +} +} +} +LEAN_EXPORT lean_object* l_List_partition_loop___at_Lake_FetchM_run___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_3, 1); +x_7 = l_List_reverse___rarg(x_5); +x_8 = l_List_reverse___rarg(x_6); +lean_ctor_set(x_3, 1, x_8); +lean_ctor_set(x_3, 0, x_7); +return x_3; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_9 = lean_ctor_get(x_3, 0); +x_10 = lean_ctor_get(x_3, 1); +lean_inc(x_10); +lean_inc(x_9); +lean_dec(x_3); +x_11 = l_List_reverse___rarg(x_9); +x_12 = l_List_reverse___rarg(x_10); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_12); +return x_13; +} +} +else +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_2); +if (x_14 == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_3); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_16 = lean_ctor_get(x_2, 0); +x_17 = lean_ctor_get(x_2, 1); +x_18 = lean_ctor_get(x_3, 0); +x_19 = lean_ctor_get(x_3, 1); +x_20 = l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(x_16, x_1); +if (x_20 == 0) +{ +lean_ctor_set(x_2, 1, x_18); +lean_ctor_set(x_3, 0, x_2); +x_2 = x_17; +goto _start; +} +else +{ +lean_ctor_set(x_2, 1, x_19); +lean_ctor_set(x_3, 1, x_2); +x_2 = x_17; +goto _start; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; +x_23 = lean_ctor_get(x_2, 0); +x_24 = lean_ctor_get(x_2, 1); +x_25 = lean_ctor_get(x_3, 0); +x_26 = lean_ctor_get(x_3, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_3); +x_27 = l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(x_23, x_1); +if (x_27 == 0) +{ +lean_object* x_28; +lean_ctor_set(x_2, 1, x_25); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_2); +lean_ctor_set(x_28, 1, x_26); +x_2 = x_24; +x_3 = x_28; +goto _start; +} +else +{ +lean_object* x_30; +lean_ctor_set(x_2, 1, x_26); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_25); +lean_ctor_set(x_30, 1, x_2); +x_2 = x_24; +x_3 = x_30; +goto _start; +} +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_32 = lean_ctor_get(x_2, 0); +x_33 = lean_ctor_get(x_2, 1); +lean_inc(x_33); +lean_inc(x_32); +lean_dec(x_2); +x_34 = lean_ctor_get(x_3, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_3, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + x_36 = x_3; +} else { + lean_dec_ref(x_3); + x_36 = lean_box(0); +} +x_37 = l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(x_32, x_1); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_32); +lean_ctor_set(x_38, 1, x_34); +if (lean_is_scalar(x_36)) { + x_39 = lean_alloc_ctor(0, 2, 0); +} else { + x_39 = x_36; +} +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_35); +x_2 = x_33; +x_3 = x_39; +goto _start; +} +else +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_32); +lean_ctor_set(x_41, 1, x_35); +if (lean_is_scalar(x_36)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_36; +} +lean_ctor_set(x_42, 0, x_34); +lean_ctor_set(x_42, 1, x_41); +x_2 = x_33; +x_3 = x_42; +goto _start; +} +} +} +} +} +static lean_object* _init_l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("\n", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("build cycle detected:\n", 22); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_7 = lean_box(0); +x_8 = l_List_mapTR_loop___at_Lake_instMonadCycleOfBuildKeyRecBuildM___spec__2(x_1, x_7); +x_9 = l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__1; +x_10 = l_String_intercalate(x_9, x_8); +x_11 = l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__2; +x_12 = lean_string_append(x_11, x_10); +lean_dec(x_10); +x_13 = l_Lake_ExternLib_recBuildStatic___closed__2; +x_14 = lean_string_append(x_12, x_13); +x_15 = 3; +x_16 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_16, 0, x_14); +lean_ctor_set_uint8(x_16, sizeof(void*)*1, x_15); +x_17 = lean_array_get_size(x_4); +x_18 = lean_array_push(x_4, x_16); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_18); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_5); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_6); +return x_21; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___boxed), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_recFetch___at_Lake_FetchM_run___spec__7(x_2, x_1, x_4, x_5, x_6, x_7); +return x_8; +} +} +static lean_object* _init_l_Lake_recFetch___at_Lake_FetchM_run___spec__7___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_box(0); +x_2 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_2, 0, x_1); +lean_ctor_set(x_2, 1, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; uint8_t x_8; +lean_inc(x_1); +x_7 = l_Lake_BuildInfo_key(x_1); +x_8 = l_List_elem___at_Lake_FetchM_run___spec__1(x_7, x_2); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_inc(x_7); +x_9 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_9, 0, x_7); +lean_ctor_set(x_9, 1, x_2); +lean_inc(x_9); +x_10 = lean_alloc_closure((void*)(l_Lake_recFetch___at_Lake_FetchM_run___spec__7___lambda__1___boxed), 7, 1); +lean_closure_set(x_10, 0, x_9); +x_11 = l_Lake_RBNode_dFind___at_Lake_FetchM_run___spec__2(x_5, x_7); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; +x_12 = l_Lake_recBuildWithIndex(x_1, x_10, x_9, x_3, x_4, x_5, x_6); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_12); +if (x_15 == 0) +{ +lean_object* x_16; uint8_t x_17; +x_16 = lean_ctor_get(x_12, 0); +lean_dec(x_16); +x_17 = !lean_is_exclusive(x_13); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_18 = lean_ctor_get(x_13, 1); +x_19 = lean_ctor_get(x_13, 0); +lean_dec(x_19); +x_20 = !lean_is_exclusive(x_14); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_14, 0); +lean_inc(x_21); +x_22 = l_Lean_RBNode_insert___at_Lake_FetchM_run___spec__3(x_18, x_7, x_21); +lean_ctor_set(x_13, 1, x_22); +return x_12; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_14, 0); +x_24 = lean_ctor_get(x_14, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_14); +lean_inc(x_23); +x_25 = l_Lean_RBNode_insert___at_Lake_FetchM_run___spec__3(x_18, x_7, x_23); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_23); +lean_ctor_set(x_26, 1, x_24); +lean_ctor_set(x_13, 1, x_25); +lean_ctor_set(x_13, 0, x_26); +return x_12; +} +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_27 = lean_ctor_get(x_13, 1); +lean_inc(x_27); +lean_dec(x_13); +x_28 = lean_ctor_get(x_14, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_14, 1); +lean_inc(x_29); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_30 = x_14; +} else { + lean_dec_ref(x_14); + x_30 = lean_box(0); +} +lean_inc(x_28); +x_31 = l_Lean_RBNode_insert___at_Lake_FetchM_run___spec__3(x_27, x_7, x_28); +if (lean_is_scalar(x_30)) { + x_32 = lean_alloc_ctor(0, 2, 0); +} else { + x_32 = x_30; +} +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_29); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_31); +lean_ctor_set(x_12, 0, x_33); +return x_12; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_34 = lean_ctor_get(x_12, 1); +lean_inc(x_34); +lean_dec(x_12); +x_35 = lean_ctor_get(x_13, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_36 = x_13; +} else { + lean_dec_ref(x_13); + x_36 = lean_box(0); +} +x_37 = lean_ctor_get(x_14, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_14, 1); +lean_inc(x_38); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_39 = x_14; +} else { + lean_dec_ref(x_14); + x_39 = lean_box(0); +} +lean_inc(x_37); +x_40 = l_Lean_RBNode_insert___at_Lake_FetchM_run___spec__3(x_35, x_7, x_37); +if (lean_is_scalar(x_39)) { + x_41 = lean_alloc_ctor(0, 2, 0); +} else { + x_41 = x_39; +} +lean_ctor_set(x_41, 0, x_37); +lean_ctor_set(x_41, 1, x_38); +if (lean_is_scalar(x_36)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_36; +} +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_34); +return x_43; +} +} +else +{ +uint8_t x_44; +lean_dec(x_7); +x_44 = !lean_is_exclusive(x_12); +if (x_44 == 0) +{ +lean_object* x_45; uint8_t x_46; +x_45 = lean_ctor_get(x_12, 0); +lean_dec(x_45); +x_46 = !lean_is_exclusive(x_13); +if (x_46 == 0) +{ +lean_object* x_47; uint8_t x_48; +x_47 = lean_ctor_get(x_13, 0); +lean_dec(x_47); +x_48 = !lean_is_exclusive(x_14); +if (x_48 == 0) +{ +return x_12; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_14, 0); +x_50 = lean_ctor_get(x_14, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_14); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +lean_ctor_set(x_13, 0, x_51); +return x_12; +} +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_52 = lean_ctor_get(x_13, 1); +lean_inc(x_52); +lean_dec(x_13); +x_53 = lean_ctor_get(x_14, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_14, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_55 = x_14; +} else { + lean_dec_ref(x_14); + x_55 = lean_box(0); +} +if (lean_is_scalar(x_55)) { + x_56 = lean_alloc_ctor(1, 2, 0); +} else { + x_56 = x_55; +} +lean_ctor_set(x_56, 0, x_53); +lean_ctor_set(x_56, 1, x_54); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_52); +lean_ctor_set(x_12, 0, x_57); +return x_12; +} +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_58 = lean_ctor_get(x_12, 1); +lean_inc(x_58); +lean_dec(x_12); +x_59 = lean_ctor_get(x_13, 1); +lean_inc(x_59); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_60 = x_13; +} else { + lean_dec_ref(x_13); + x_60 = lean_box(0); +} +x_61 = lean_ctor_get(x_14, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_14, 1); +lean_inc(x_62); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_63 = x_14; +} else { + lean_dec_ref(x_14); + x_63 = lean_box(0); +} +if (lean_is_scalar(x_63)) { + x_64 = lean_alloc_ctor(1, 2, 0); +} else { + x_64 = x_63; +} +lean_ctor_set(x_64, 0, x_61); +lean_ctor_set(x_64, 1, x_62); +if (lean_is_scalar(x_60)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_60; +} +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_58); +return x_66; +} +} +} +else +{ +uint8_t x_67; +lean_dec(x_7); +x_67 = !lean_is_exclusive(x_12); +if (x_67 == 0) +{ +return x_12; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_12, 0); +x_69 = lean_ctor_get(x_12, 1); +lean_inc(x_69); +lean_inc(x_68); +lean_dec(x_12); +x_70 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_70, 0, x_68); +lean_ctor_set(x_70, 1, x_69); +return x_70; +} +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_71 = lean_ctor_get(x_11, 0); +lean_inc(x_71); +lean_dec(x_11); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_4); +x_73 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_5); +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_6); +return x_74; +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +lean_dec(x_1); +x_75 = lean_box(0); +x_76 = l_Lake_recFetch___at_Lake_FetchM_run___spec__7___closed__1; +lean_inc(x_2); +x_77 = l_List_partition_loop___at_Lake_FetchM_run___spec__5(x_7, x_2, x_76); +x_78 = lean_ctor_get(x_77, 0); +lean_inc(x_78); +lean_dec(x_77); +lean_inc(x_7); +x_79 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_79, 0, x_7); +lean_ctor_set(x_79, 1, x_78); +x_80 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_80, 0, x_7); +lean_ctor_set(x_80, 1, x_75); +x_81 = l_List_appendTR___rarg(x_79, x_80); +x_82 = l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg(x_81, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_3); +lean_dec(x_2); +return x_82; +} +} +} +static lean_object* _init_l_Lake_FetchM_run___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_recFetch___at_Lake_FetchM_run___spec__7), 6, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_FetchM_run___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; +x_7 = l_Lake_FetchM_run___rarg___closed__1; +x_8 = lean_apply_6(x_1, x_7, x_2, x_3, x_4, x_5, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_FetchM_run(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_FetchM_run___rarg), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_List_elem___at_Lake_FetchM_run___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_List_elem___at_Lake_FetchM_run___spec__1(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_FetchM_run___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_RBNode_dFind___at_Lake_FetchM_run___spec__2(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_List_partition_loop___at_Lake_FetchM_run___spec__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_partition_loop___at_Lake_FetchM_run___spec__5(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_3); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_recFetch___at_Lake_FetchM_run___spec__7___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_3); +return x_8; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Executable(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Topological(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Index(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Executable(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Topological(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_ExternLib_recBuildStatic___closed__1 = _init_l_Lake_ExternLib_recBuildStatic___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_recBuildStatic___closed__1); +l_Lake_ExternLib_recBuildStatic___closed__2 = _init_l_Lake_ExternLib_recBuildStatic___closed__2(); +lean_mark_persistent(l_Lake_ExternLib_recBuildStatic___closed__2); +l_Lake_ExternLib_recBuildStatic___closed__3 = _init_l_Lake_ExternLib_recBuildStatic___closed__3(); +lean_mark_persistent(l_Lake_ExternLib_recBuildStatic___closed__3); +l_Lake_ExternLib_recBuildShared___lambda__1___closed__1 = _init_l_Lake_ExternLib_recBuildShared___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_recBuildShared___lambda__1___closed__1); +l_Lake_ExternLib_recBuildShared___closed__1 = _init_l_Lake_ExternLib_recBuildShared___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_recBuildShared___closed__1); +l_Lake_ExternLib_recComputeDynlib___closed__1 = _init_l_Lake_ExternLib_recComputeDynlib___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_recComputeDynlib___closed__1); +l_Lake_ExternLib_recComputeDynlib___closed__2 = _init_l_Lake_ExternLib_recComputeDynlib___closed__2(); +lean_mark_persistent(l_Lake_ExternLib_recComputeDynlib___closed__2); +l_Lake_recBuildWithIndex___closed__1 = _init_l_Lake_recBuildWithIndex___closed__1(); +lean_mark_persistent(l_Lake_recBuildWithIndex___closed__1); +l_Lake_recBuildWithIndex___closed__2 = _init_l_Lake_recBuildWithIndex___closed__2(); +lean_mark_persistent(l_Lake_recBuildWithIndex___closed__2); +l_Lake_recBuildWithIndex___closed__3 = _init_l_Lake_recBuildWithIndex___closed__3(); +lean_mark_persistent(l_Lake_recBuildWithIndex___closed__3); +l_Lake_recBuildWithIndex___closed__4 = _init_l_Lake_recBuildWithIndex___closed__4(); +lean_mark_persistent(l_Lake_recBuildWithIndex___closed__4); +l_Lake_recBuildWithIndex___closed__5 = _init_l_Lake_recBuildWithIndex___closed__5(); +lean_mark_persistent(l_Lake_recBuildWithIndex___closed__5); +l_Lake_recBuildWithIndex___closed__6 = _init_l_Lake_recBuildWithIndex___closed__6(); +lean_mark_persistent(l_Lake_recBuildWithIndex___closed__6); +l_Lake_recBuildWithIndex___closed__7 = _init_l_Lake_recBuildWithIndex___closed__7(); +lean_mark_persistent(l_Lake_recBuildWithIndex___closed__7); +l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__1 = _init_l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__1(); +lean_mark_persistent(l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__1); +l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__2 = _init_l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__2(); +lean_mark_persistent(l_Lake_buildCycleError___at_Lake_FetchM_run___spec__6___rarg___closed__2); +l_Lake_recFetch___at_Lake_FetchM_run___spec__7___closed__1 = _init_l_Lake_recFetch___at_Lake_FetchM_run___spec__7___closed__1(); +lean_mark_persistent(l_Lake_recFetch___at_Lake_FetchM_run___spec__7___closed__1); +l_Lake_FetchM_run___rarg___closed__1 = _init_l_Lake_FetchM_run___rarg___closed__1(); +lean_mark_persistent(l_Lake_FetchM_run___rarg___closed__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Info.c b/stage0/stdlib/Lake/Build/Info.c new file mode 100644 index 0000000000..35fb22ab37 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Info.c @@ -0,0 +1,1724 @@ +// Lean compiler output +// Module: Lake.Build.Info +// Imports: Init Lake.Config.LeanExe Lake.Config.ExternLib Lake.Build.Facets +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_ExternLib_staticBuildKey___closed__3; +LEAN_EXPORT lean_object* l_Lake_Module_precompileImports(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_facetBuildKey(lean_object*, lean_object*); +static lean_object* l_Lake_Package_extraDep___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanLib_shared(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_modules(lean_object*); +static lean_object* l_Lake_LeanLib_shared___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_static(lean_object*); +static lean_object* l_Lake_Module_bc___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_targetBuildKey___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_leanArts(lean_object*); +static lean_object* l_Lake_Module_bc___closed__1; +LEAN_EXPORT lean_object* l_Lake_Package_depsFacet; +static lean_object* l_Lake_Module_leanArts___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildInfo_key(lean_object*); +static lean_object* l_Lake_Module_olean___closed__1; +static lean_object* l_Lake_Module_coExport___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_modulesFacet; +LEAN_EXPORT lean_object* l_Lake_Module_transImports(lean_object*); +static lean_object* l_Lake_Module_precompileImportsFacet___closed__1; +static lean_object* l_Lake_ExternLib_staticBuildKey___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_c(lean_object*); +static lean_object* l_Lake_Module_bco___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_oNoExport(lean_object*); +static lean_object* l_Lake_Module_importsFacet___closed__3; +LEAN_EXPORT lean_object* l_Lake_Package_optRelease(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_transImportsFacet; +static lean_object* l_Lake_LeanLib_facetBuildKey___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_release(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_bc(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_bco(lean_object*); +static lean_object* l_Lake_Module_olean___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanExe_buildKey___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_deps(lean_object*); +static lean_object* l_Lake_LeanLib_modulesFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_ExternLib_dynlibBuildKey(lean_object*); +static lean_object* l_Lake_Package_optRelease___closed__1; +LEAN_EXPORT lean_object* l_Lake_Package_facet(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_facetBuildKey(lean_object*, lean_object*); +lean_object* l_Lean_Name_mkStr3(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_transImportsFacet___closed__2; +static lean_object* l_Lake_ExternLib_sharedBuildKey___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_facet(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ExternLib_dynlib(lean_object*); +static lean_object* l_Lake_Module_oNoExport___closed__1; +static lean_object* l_Lake_LeanExe_buildKey___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_oExport(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_coNoExport(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_leanArts(lean_object*); +static lean_object* l_Lake_Module_oNoExport___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_coExport(lean_object*); +static lean_object* l_Lake_Module_importsFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_ExternLib_sharedBuildKey(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_extraDep(lean_object*); +LEAN_EXPORT lean_object* l_Lake_ExternLib_shared(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanExe_buildKey(lean_object*); +lean_object* l_Lean_Name_append(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_co(lean_object*); +static lean_object* l_Lake_Module_precompileImportsFacet___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_facetBuildKey___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_ExternLib_sharedBuildKey___closed__2; +static lean_object* l_Lake_LeanExe_buildKey___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_targetBuildKey(lean_object*, lean_object*); +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +static lean_object* l_Lake_Module_coNoExport___closed__1; +static lean_object* l_Lake_Module_o___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_target(lean_object*, lean_object*); +static lean_object* l_Lake_Module_ilean___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_facet(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_facetBuildKey___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_facetBuildKey(lean_object*, lean_object*); +static lean_object* l_Lake_Module_transImportsFacet___closed__1; +static lean_object* l_Lake_LeanLib_staticExport___closed__1; +static lean_object* l_Lake_Module_leanArts___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_o(lean_object*); +static lean_object* l_Lake_Module_c___closed__1; +static lean_object* l_Lake_Module_importsFacet___closed__2; +static lean_object* l_Lake_Module_c___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticExport(lean_object*); +static lean_object* l_Lake_Package_depsFacet___closed__2; +static lean_object* l_Lake_Module_dynlibFacet___closed__1; +static lean_object* l_Lake_ExternLib_dynlibBuildKey___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_ilean(lean_object*); +static lean_object* l_Lake_Module_co___closed__1; +static lean_object* l_Lake_Package_release___closed__1; +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +static lean_object* l_Lake_Module_ilean___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_imports(lean_object*); +static lean_object* l_Lake_ExternLib_staticBuildKey___closed__1; +static lean_object* l_Lake_LeanLib_facetBuildKey___closed__1; +static lean_object* l_Lake_Package_release___closed__2; +static lean_object* l_Lake_LeanLib_static___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_importsFacet; +LEAN_EXPORT lean_object* l_Lake_ExternLib_staticBuildKey(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_dynlib(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_extraDep(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_facetBuildKey___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_precompileImportsFacet; +LEAN_EXPORT lean_object* l_Lake_ExternLib_static(lean_object*); +static lean_object* l_Lake_Package_depsFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_dynlibFacet; +static lean_object* l_Lake_Module_o___closed__1; +static lean_object* l_Lake_Module_oExport___closed__1; +static lean_object* l_Lake_ExternLib_dynlibBuildKey___closed__2; +static lean_object* l_Lake_Module_oExport___closed__2; +static lean_object* l_Lake_Package_extraDep___closed__1; +static lean_object* l_Lake_LeanLib_modulesFacet___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanExe_exe(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_olean(lean_object*); +static lean_object* l_Lake_Package_optRelease___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_facetBuildKey(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_2, 2); +lean_inc(x_3); +x_4 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_4, 0, x_3); +lean_ctor_set(x_4, 1, x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_facetBuildKey___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_Module_facetBuildKey(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_facetBuildKey(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_3 = lean_ctor_get(x_2, 2); +x_4 = lean_ctor_get(x_3, 2); +lean_inc(x_4); +x_5 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_facetBuildKey___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_Package_facetBuildKey(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_targetBuildKey(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_3 = lean_ctor_get(x_2, 2); +x_4 = lean_ctor_get(x_3, 2); +lean_inc(x_4); +x_5 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_targetBuildKey___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_Package_targetBuildKey(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_facetBuildKey___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanLib", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_facetBuildKey___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_facetBuildKey___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_facetBuildKey(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_4, 2); +x_6 = lean_ctor_get(x_5, 2); +x_7 = lean_ctor_get(x_3, 1); +x_8 = l_Lake_LeanLib_facetBuildKey___closed__2; +x_9 = l_Lean_Name_append(x_8, x_2); +lean_inc(x_7); +lean_inc(x_6); +x_10 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_10, 0, x_6); +lean_ctor_set(x_10, 1, x_7); +lean_ctor_set(x_10, 2, x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_facetBuildKey___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_LeanLib_facetBuildKey(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanExe_buildKey___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanExe", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanExe_buildKey___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanExe_buildKey___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExe_buildKey(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_2 = lean_ctor_get(x_1, 1); +x_3 = lean_ctor_get(x_1, 0); +x_4 = lean_ctor_get(x_3, 2); +x_5 = lean_ctor_get(x_4, 2); +x_6 = lean_ctor_get(x_2, 1); +x_7 = l_Lake_LeanExe_buildKey___closed__2; +lean_inc(x_6); +lean_inc(x_5); +x_8 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_8, 0, x_5); +lean_ctor_set(x_8, 1, x_6); +lean_ctor_set(x_8, 2, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExe_buildKey___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_LeanExe_buildKey(x_1); +lean_dec(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_ExternLib_staticBuildKey___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("externLib", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_staticBuildKey___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("static", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_staticBuildKey___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_ExternLib_staticBuildKey___closed__1; +x_2 = l_Lake_ExternLib_staticBuildKey___closed__2; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_staticBuildKey(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = lean_ctor_get(x_1, 2); +lean_dec(x_4); +x_5 = lean_ctor_get(x_3, 2); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_ctor_get(x_5, 2); +lean_inc(x_6); +lean_dec(x_5); +x_7 = l_Lake_ExternLib_staticBuildKey___closed__3; +lean_ctor_set_tag(x_1, 2); +lean_ctor_set(x_1, 2, x_7); +lean_ctor_set(x_1, 0, x_6); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = lean_ctor_get(x_8, 2); +lean_inc(x_10); +lean_dec(x_8); +x_11 = lean_ctor_get(x_10, 2); +lean_inc(x_11); +lean_dec(x_10); +x_12 = l_Lake_ExternLib_staticBuildKey___closed__3; +x_13 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_9); +lean_ctor_set(x_13, 2, x_12); +return x_13; +} +} +} +static lean_object* _init_l_Lake_ExternLib_sharedBuildKey___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("shared", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_sharedBuildKey___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_ExternLib_staticBuildKey___closed__1; +x_2 = l_Lake_ExternLib_sharedBuildKey___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_sharedBuildKey(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = lean_ctor_get(x_1, 2); +lean_dec(x_4); +x_5 = lean_ctor_get(x_3, 2); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_ctor_get(x_5, 2); +lean_inc(x_6); +lean_dec(x_5); +x_7 = l_Lake_ExternLib_sharedBuildKey___closed__2; +lean_ctor_set_tag(x_1, 2); +lean_ctor_set(x_1, 2, x_7); +lean_ctor_set(x_1, 0, x_6); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = lean_ctor_get(x_8, 2); +lean_inc(x_10); +lean_dec(x_8); +x_11 = lean_ctor_get(x_10, 2); +lean_inc(x_11); +lean_dec(x_10); +x_12 = l_Lake_ExternLib_sharedBuildKey___closed__2; +x_13 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_9); +lean_ctor_set(x_13, 2, x_12); +return x_13; +} +} +} +static lean_object* _init_l_Lake_ExternLib_dynlibBuildKey___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("dynlib", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_ExternLib_dynlibBuildKey___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_ExternLib_staticBuildKey___closed__1; +x_2 = l_Lake_ExternLib_dynlibBuildKey___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_dynlibBuildKey(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = lean_ctor_get(x_1, 2); +lean_dec(x_4); +x_5 = lean_ctor_get(x_3, 2); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_ctor_get(x_5, 2); +lean_inc(x_6); +lean_dec(x_5); +x_7 = l_Lake_ExternLib_dynlibBuildKey___closed__2; +lean_ctor_set_tag(x_1, 2); +lean_ctor_set(x_1, 2, x_7); +lean_ctor_set(x_1, 0, x_6); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = lean_ctor_get(x_8, 2); +lean_inc(x_10); +lean_dec(x_8); +x_11 = lean_ctor_get(x_10, 2); +lean_inc(x_11); +lean_dec(x_10); +x_12 = l_Lake_ExternLib_dynlibBuildKey___closed__2; +x_13 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_9); +lean_ctor_set(x_13, 2, x_12); +return x_13; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildInfo_key(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +x_4 = lean_ctor_get(x_3, 2); +lean_inc(x_4); +lean_dec(x_3); +lean_ctor_set(x_1, 0, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_1, 0); +x_6 = lean_ctor_get(x_1, 1); +lean_inc(x_6); +lean_inc(x_5); +lean_dec(x_1); +x_7 = lean_ctor_get(x_5, 2); +lean_inc(x_7); +lean_dec(x_5); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +return x_8; +} +} +case 1: +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_1); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_1, 0); +x_11 = lean_ctor_get(x_10, 2); +lean_inc(x_11); +lean_dec(x_10); +x_12 = lean_ctor_get(x_11, 2); +lean_inc(x_12); +lean_dec(x_11); +lean_ctor_set(x_1, 0, x_12); +return x_1; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_13 = lean_ctor_get(x_1, 0); +x_14 = lean_ctor_get(x_1, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_1); +x_15 = lean_ctor_get(x_13, 2); +lean_inc(x_15); +lean_dec(x_13); +x_16 = lean_ctor_get(x_15, 2); +lean_inc(x_16); +lean_dec(x_15); +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_14); +return x_17; +} +} +case 2: +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_18 = lean_ctor_get(x_1, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_18, 1); +lean_inc(x_19); +x_20 = lean_ctor_get(x_1, 1); +lean_inc(x_20); +lean_dec(x_1); +x_21 = lean_ctor_get(x_18, 0); +lean_inc(x_21); +lean_dec(x_18); +x_22 = lean_ctor_get(x_21, 2); +lean_inc(x_22); +lean_dec(x_21); +x_23 = lean_ctor_get(x_22, 2); +lean_inc(x_23); +lean_dec(x_22); +x_24 = lean_ctor_get(x_19, 1); +lean_inc(x_24); +lean_dec(x_19); +x_25 = l_Lake_LeanLib_facetBuildKey___closed__2; +x_26 = l_Lean_Name_append(x_25, x_20); +x_27 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_27, 0, x_23); +lean_ctor_set(x_27, 1, x_24); +lean_ctor_set(x_27, 2, x_26); +return x_27; +} +case 3: +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_28 = lean_ctor_get(x_1, 0); +lean_inc(x_28); +lean_dec(x_1); +x_29 = lean_ctor_get(x_28, 1); +lean_inc(x_29); +x_30 = lean_ctor_get(x_28, 0); +lean_inc(x_30); +lean_dec(x_28); +x_31 = lean_ctor_get(x_30, 2); +lean_inc(x_31); +lean_dec(x_30); +x_32 = lean_ctor_get(x_31, 2); +lean_inc(x_32); +lean_dec(x_31); +x_33 = lean_ctor_get(x_29, 1); +lean_inc(x_33); +lean_dec(x_29); +x_34 = l_Lake_LeanExe_buildKey___closed__2; +x_35 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_35, 0, x_32); +lean_ctor_set(x_35, 1, x_33); +lean_ctor_set(x_35, 2, x_34); +return x_35; +} +case 4: +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_1, 0); +lean_inc(x_36); +lean_dec(x_1); +x_37 = !lean_is_exclusive(x_36); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_38 = lean_ctor_get(x_36, 0); +x_39 = lean_ctor_get(x_36, 2); +lean_dec(x_39); +x_40 = lean_ctor_get(x_38, 2); +lean_inc(x_40); +lean_dec(x_38); +x_41 = lean_ctor_get(x_40, 2); +lean_inc(x_41); +lean_dec(x_40); +x_42 = l_Lake_ExternLib_staticBuildKey___closed__3; +lean_ctor_set_tag(x_36, 2); +lean_ctor_set(x_36, 2, x_42); +lean_ctor_set(x_36, 0, x_41); +return x_36; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_43 = lean_ctor_get(x_36, 0); +x_44 = lean_ctor_get(x_36, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_36); +x_45 = lean_ctor_get(x_43, 2); +lean_inc(x_45); +lean_dec(x_43); +x_46 = lean_ctor_get(x_45, 2); +lean_inc(x_46); +lean_dec(x_45); +x_47 = l_Lake_ExternLib_staticBuildKey___closed__3; +x_48 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_44); +lean_ctor_set(x_48, 2, x_47); +return x_48; +} +} +case 5: +{ +lean_object* x_49; uint8_t x_50; +x_49 = lean_ctor_get(x_1, 0); +lean_inc(x_49); +lean_dec(x_1); +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 2); +lean_dec(x_52); +x_53 = lean_ctor_get(x_51, 2); +lean_inc(x_53); +lean_dec(x_51); +x_54 = lean_ctor_get(x_53, 2); +lean_inc(x_54); +lean_dec(x_53); +x_55 = l_Lake_ExternLib_sharedBuildKey___closed__2; +lean_ctor_set_tag(x_49, 2); +lean_ctor_set(x_49, 2, x_55); +lean_ctor_set(x_49, 0, x_54); +return x_49; +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_56 = lean_ctor_get(x_49, 0); +x_57 = lean_ctor_get(x_49, 1); +lean_inc(x_57); +lean_inc(x_56); +lean_dec(x_49); +x_58 = lean_ctor_get(x_56, 2); +lean_inc(x_58); +lean_dec(x_56); +x_59 = lean_ctor_get(x_58, 2); +lean_inc(x_59); +lean_dec(x_58); +x_60 = l_Lake_ExternLib_sharedBuildKey___closed__2; +x_61 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_61, 0, x_59); +lean_ctor_set(x_61, 1, x_57); +lean_ctor_set(x_61, 2, x_60); +return x_61; +} +} +case 6: +{ +lean_object* x_62; uint8_t x_63; +x_62 = lean_ctor_get(x_1, 0); +lean_inc(x_62); +lean_dec(x_1); +x_63 = !lean_is_exclusive(x_62); +if (x_63 == 0) +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_64 = lean_ctor_get(x_62, 0); +x_65 = lean_ctor_get(x_62, 2); +lean_dec(x_65); +x_66 = lean_ctor_get(x_64, 2); +lean_inc(x_66); +lean_dec(x_64); +x_67 = lean_ctor_get(x_66, 2); +lean_inc(x_67); +lean_dec(x_66); +x_68 = l_Lake_ExternLib_dynlibBuildKey___closed__2; +lean_ctor_set_tag(x_62, 2); +lean_ctor_set(x_62, 2, x_68); +lean_ctor_set(x_62, 0, x_67); +return x_62; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_69 = lean_ctor_get(x_62, 0); +x_70 = lean_ctor_get(x_62, 1); +lean_inc(x_70); +lean_inc(x_69); +lean_dec(x_62); +x_71 = lean_ctor_get(x_69, 2); +lean_inc(x_71); +lean_dec(x_69); +x_72 = lean_ctor_get(x_71, 2); +lean_inc(x_72); +lean_dec(x_71); +x_73 = l_Lake_ExternLib_dynlibBuildKey___closed__2; +x_74 = lean_alloc_ctor(2, 3, 0); +lean_ctor_set(x_74, 0, x_72); +lean_ctor_set(x_74, 1, x_70); +lean_ctor_set(x_74, 2, x_73); +return x_74; +} +} +default: +{ +uint8_t x_75; +x_75 = !lean_is_exclusive(x_1); +if (x_75 == 0) +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_1, 0); +x_77 = lean_ctor_get(x_76, 2); +lean_inc(x_77); +lean_dec(x_76); +x_78 = lean_ctor_get(x_77, 2); +lean_inc(x_78); +lean_dec(x_77); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_78); +return x_1; +} +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_1, 0); +x_80 = lean_ctor_get(x_1, 1); +lean_inc(x_80); +lean_inc(x_79); +lean_dec(x_1); +x_81 = lean_ctor_get(x_79, 2); +lean_inc(x_81); +lean_dec(x_79); +x_82 = lean_ctor_get(x_81, 2); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_alloc_ctor(3, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_80); +return x_83; +} +} +} +} +} +static lean_object* _init_l_Lake_Module_importsFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("lean", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_importsFacet___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("imports", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_importsFacet___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_importsFacet___closed__1; +x_2 = l_Lake_Module_importsFacet___closed__2; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_importsFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_importsFacet___closed__3; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_transImportsFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("transImports", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_transImportsFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_importsFacet___closed__1; +x_2 = l_Lake_Module_transImportsFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_transImportsFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_transImportsFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_precompileImportsFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("precompileImports", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_precompileImportsFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_importsFacet___closed__1; +x_2 = l_Lake_Module_precompileImportsFacet___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_precompileImportsFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_precompileImportsFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_dynlibFacet___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_ExternLib_dynlibBuildKey___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_dynlibFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_dynlibFacet___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("modules", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_modulesFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_modulesFacet___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_Package_depsFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("deps", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_depsFacet___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_depsFacet___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_depsFacet() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_depsFacet___closed__2; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_facet(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_imports(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_importsFacet___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_transImports(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_transImportsFacet___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_precompileImports(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_precompileImportsFacet___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_deps(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Package_depsFacet___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_leanArts___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanArts", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_leanArts___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_leanArts___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_leanArts(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_leanArts___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_olean___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("olean", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_olean___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_olean___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_olean(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_olean___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_ilean___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("ilean", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_ilean___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_ilean___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_ilean(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_ilean___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_c___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("c", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_c___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_c___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_c(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_c___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bc___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("bc", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_bc___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_bc___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_bc(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_bc___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_o___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("o", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_o___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_o___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_o(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_o___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oExport___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("export", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oExport___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_o___closed__1; +x_2 = l_Lake_Module_oExport___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oExport(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_oExport___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oNoExport___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("noexport", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oNoExport___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_o___closed__1; +x_2 = l_Lake_Module_oNoExport___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oNoExport(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_oNoExport___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_co___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_c___closed__1; +x_2 = l_Lake_Module_o___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_co(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_co___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_coExport___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Module_c___closed__1; +x_2 = l_Lake_Module_o___closed__1; +x_3 = l_Lake_Module_oExport___closed__1; +x_4 = l_Lean_Name_mkStr3(x_1, x_2, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_coExport(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_coExport___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_coNoExport___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Module_c___closed__1; +x_2 = l_Lake_Module_o___closed__1; +x_3 = l_Lake_Module_oNoExport___closed__1; +x_4 = l_Lean_Name_mkStr3(x_1, x_2, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_coNoExport(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_coNoExport___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bco___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_bc___closed__1; +x_2 = l_Lake_Module_o___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_bco(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_bco___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_dynlib(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_dynlibFacet___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_facet(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_release___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("release", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_release___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_release___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_release(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Package_release___closed__2; +x_3 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_optRelease___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("optRelease", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_optRelease___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_optRelease___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_optRelease(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Package_optRelease___closed__2; +x_3 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_extraDep___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("extraDep", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_extraDep___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_extraDep___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_extraDep(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Package_extraDep___closed__2; +x_3 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_target(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_facet(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_modules(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_LeanLib_modulesFacet___closed__2; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_leanArts(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Module_leanArts___closed__2; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_static___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_ExternLib_staticBuildKey___closed__2; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_static(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_LeanLib_static___closed__1; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_staticExport___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_ExternLib_staticBuildKey___closed__2; +x_2 = l_Lake_Module_oExport___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticExport(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_LeanLib_staticExport___closed__1; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_shared___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_ExternLib_sharedBuildKey___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_shared(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_LeanLib_shared___closed__1; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_extraDep(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_Package_extraDep___closed__2; +x_3 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExe_exe(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_static(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_shared(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_ExternLib_dynlib(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_ctor(6, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Config_LeanExe(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Config_ExternLib(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Facets(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Info(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Config_LeanExe(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Config_ExternLib(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Facets(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_LeanLib_facetBuildKey___closed__1 = _init_l_Lake_LeanLib_facetBuildKey___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_facetBuildKey___closed__1); +l_Lake_LeanLib_facetBuildKey___closed__2 = _init_l_Lake_LeanLib_facetBuildKey___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_facetBuildKey___closed__2); +l_Lake_LeanExe_buildKey___closed__1 = _init_l_Lake_LeanExe_buildKey___closed__1(); +lean_mark_persistent(l_Lake_LeanExe_buildKey___closed__1); +l_Lake_LeanExe_buildKey___closed__2 = _init_l_Lake_LeanExe_buildKey___closed__2(); +lean_mark_persistent(l_Lake_LeanExe_buildKey___closed__2); +l_Lake_ExternLib_staticBuildKey___closed__1 = _init_l_Lake_ExternLib_staticBuildKey___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_staticBuildKey___closed__1); +l_Lake_ExternLib_staticBuildKey___closed__2 = _init_l_Lake_ExternLib_staticBuildKey___closed__2(); +lean_mark_persistent(l_Lake_ExternLib_staticBuildKey___closed__2); +l_Lake_ExternLib_staticBuildKey___closed__3 = _init_l_Lake_ExternLib_staticBuildKey___closed__3(); +lean_mark_persistent(l_Lake_ExternLib_staticBuildKey___closed__3); +l_Lake_ExternLib_sharedBuildKey___closed__1 = _init_l_Lake_ExternLib_sharedBuildKey___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_sharedBuildKey___closed__1); +l_Lake_ExternLib_sharedBuildKey___closed__2 = _init_l_Lake_ExternLib_sharedBuildKey___closed__2(); +lean_mark_persistent(l_Lake_ExternLib_sharedBuildKey___closed__2); +l_Lake_ExternLib_dynlibBuildKey___closed__1 = _init_l_Lake_ExternLib_dynlibBuildKey___closed__1(); +lean_mark_persistent(l_Lake_ExternLib_dynlibBuildKey___closed__1); +l_Lake_ExternLib_dynlibBuildKey___closed__2 = _init_l_Lake_ExternLib_dynlibBuildKey___closed__2(); +lean_mark_persistent(l_Lake_ExternLib_dynlibBuildKey___closed__2); +l_Lake_Module_importsFacet___closed__1 = _init_l_Lake_Module_importsFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_importsFacet___closed__1); +l_Lake_Module_importsFacet___closed__2 = _init_l_Lake_Module_importsFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_importsFacet___closed__2); +l_Lake_Module_importsFacet___closed__3 = _init_l_Lake_Module_importsFacet___closed__3(); +lean_mark_persistent(l_Lake_Module_importsFacet___closed__3); +l_Lake_Module_importsFacet = _init_l_Lake_Module_importsFacet(); +lean_mark_persistent(l_Lake_Module_importsFacet); +l_Lake_Module_transImportsFacet___closed__1 = _init_l_Lake_Module_transImportsFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_transImportsFacet___closed__1); +l_Lake_Module_transImportsFacet___closed__2 = _init_l_Lake_Module_transImportsFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_transImportsFacet___closed__2); +l_Lake_Module_transImportsFacet = _init_l_Lake_Module_transImportsFacet(); +lean_mark_persistent(l_Lake_Module_transImportsFacet); +l_Lake_Module_precompileImportsFacet___closed__1 = _init_l_Lake_Module_precompileImportsFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_precompileImportsFacet___closed__1); +l_Lake_Module_precompileImportsFacet___closed__2 = _init_l_Lake_Module_precompileImportsFacet___closed__2(); +lean_mark_persistent(l_Lake_Module_precompileImportsFacet___closed__2); +l_Lake_Module_precompileImportsFacet = _init_l_Lake_Module_precompileImportsFacet(); +lean_mark_persistent(l_Lake_Module_precompileImportsFacet); +l_Lake_Module_dynlibFacet___closed__1 = _init_l_Lake_Module_dynlibFacet___closed__1(); +lean_mark_persistent(l_Lake_Module_dynlibFacet___closed__1); +l_Lake_Module_dynlibFacet = _init_l_Lake_Module_dynlibFacet(); +lean_mark_persistent(l_Lake_Module_dynlibFacet); +l_Lake_LeanLib_modulesFacet___closed__1 = _init_l_Lake_LeanLib_modulesFacet___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacet___closed__1); +l_Lake_LeanLib_modulesFacet___closed__2 = _init_l_Lake_LeanLib_modulesFacet___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacet___closed__2); +l_Lake_LeanLib_modulesFacet = _init_l_Lake_LeanLib_modulesFacet(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacet); +l_Lake_Package_depsFacet___closed__1 = _init_l_Lake_Package_depsFacet___closed__1(); +lean_mark_persistent(l_Lake_Package_depsFacet___closed__1); +l_Lake_Package_depsFacet___closed__2 = _init_l_Lake_Package_depsFacet___closed__2(); +lean_mark_persistent(l_Lake_Package_depsFacet___closed__2); +l_Lake_Package_depsFacet = _init_l_Lake_Package_depsFacet(); +lean_mark_persistent(l_Lake_Package_depsFacet); +l_Lake_Module_leanArts___closed__1 = _init_l_Lake_Module_leanArts___closed__1(); +lean_mark_persistent(l_Lake_Module_leanArts___closed__1); +l_Lake_Module_leanArts___closed__2 = _init_l_Lake_Module_leanArts___closed__2(); +lean_mark_persistent(l_Lake_Module_leanArts___closed__2); +l_Lake_Module_olean___closed__1 = _init_l_Lake_Module_olean___closed__1(); +lean_mark_persistent(l_Lake_Module_olean___closed__1); +l_Lake_Module_olean___closed__2 = _init_l_Lake_Module_olean___closed__2(); +lean_mark_persistent(l_Lake_Module_olean___closed__2); +l_Lake_Module_ilean___closed__1 = _init_l_Lake_Module_ilean___closed__1(); +lean_mark_persistent(l_Lake_Module_ilean___closed__1); +l_Lake_Module_ilean___closed__2 = _init_l_Lake_Module_ilean___closed__2(); +lean_mark_persistent(l_Lake_Module_ilean___closed__2); +l_Lake_Module_c___closed__1 = _init_l_Lake_Module_c___closed__1(); +lean_mark_persistent(l_Lake_Module_c___closed__1); +l_Lake_Module_c___closed__2 = _init_l_Lake_Module_c___closed__2(); +lean_mark_persistent(l_Lake_Module_c___closed__2); +l_Lake_Module_bc___closed__1 = _init_l_Lake_Module_bc___closed__1(); +lean_mark_persistent(l_Lake_Module_bc___closed__1); +l_Lake_Module_bc___closed__2 = _init_l_Lake_Module_bc___closed__2(); +lean_mark_persistent(l_Lake_Module_bc___closed__2); +l_Lake_Module_o___closed__1 = _init_l_Lake_Module_o___closed__1(); +lean_mark_persistent(l_Lake_Module_o___closed__1); +l_Lake_Module_o___closed__2 = _init_l_Lake_Module_o___closed__2(); +lean_mark_persistent(l_Lake_Module_o___closed__2); +l_Lake_Module_oExport___closed__1 = _init_l_Lake_Module_oExport___closed__1(); +lean_mark_persistent(l_Lake_Module_oExport___closed__1); +l_Lake_Module_oExport___closed__2 = _init_l_Lake_Module_oExport___closed__2(); +lean_mark_persistent(l_Lake_Module_oExport___closed__2); +l_Lake_Module_oNoExport___closed__1 = _init_l_Lake_Module_oNoExport___closed__1(); +lean_mark_persistent(l_Lake_Module_oNoExport___closed__1); +l_Lake_Module_oNoExport___closed__2 = _init_l_Lake_Module_oNoExport___closed__2(); +lean_mark_persistent(l_Lake_Module_oNoExport___closed__2); +l_Lake_Module_co___closed__1 = _init_l_Lake_Module_co___closed__1(); +lean_mark_persistent(l_Lake_Module_co___closed__1); +l_Lake_Module_coExport___closed__1 = _init_l_Lake_Module_coExport___closed__1(); +lean_mark_persistent(l_Lake_Module_coExport___closed__1); +l_Lake_Module_coNoExport___closed__1 = _init_l_Lake_Module_coNoExport___closed__1(); +lean_mark_persistent(l_Lake_Module_coNoExport___closed__1); +l_Lake_Module_bco___closed__1 = _init_l_Lake_Module_bco___closed__1(); +lean_mark_persistent(l_Lake_Module_bco___closed__1); +l_Lake_Package_release___closed__1 = _init_l_Lake_Package_release___closed__1(); +lean_mark_persistent(l_Lake_Package_release___closed__1); +l_Lake_Package_release___closed__2 = _init_l_Lake_Package_release___closed__2(); +lean_mark_persistent(l_Lake_Package_release___closed__2); +l_Lake_Package_optRelease___closed__1 = _init_l_Lake_Package_optRelease___closed__1(); +lean_mark_persistent(l_Lake_Package_optRelease___closed__1); +l_Lake_Package_optRelease___closed__2 = _init_l_Lake_Package_optRelease___closed__2(); +lean_mark_persistent(l_Lake_Package_optRelease___closed__2); +l_Lake_Package_extraDep___closed__1 = _init_l_Lake_Package_extraDep___closed__1(); +lean_mark_persistent(l_Lake_Package_extraDep___closed__1); +l_Lake_Package_extraDep___closed__2 = _init_l_Lake_Package_extraDep___closed__2(); +lean_mark_persistent(l_Lake_Package_extraDep___closed__2); +l_Lake_LeanLib_static___closed__1 = _init_l_Lake_LeanLib_static___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_static___closed__1); +l_Lake_LeanLib_staticExport___closed__1 = _init_l_Lake_LeanLib_staticExport___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_staticExport___closed__1); +l_Lake_LeanLib_shared___closed__1 = _init_l_Lake_LeanLib_shared___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_shared___closed__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Job.c b/stage0/stdlib/Lake/Build/Job.c new file mode 100644 index 0000000000..645955801a --- /dev/null +++ b/stage0/stdlib/Lake/Build/Job.c @@ -0,0 +1,25371 @@ +// Lean compiler output +// Module: Lake.Build.Job +// Imports: Init Lake.Util.Task Lake.Build.Basic +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_instMonadStateOfLogJobM___closed__4; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1(lean_object*); +static lean_object* l_Lake_OpaqueJob_instCoeBundledJob___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith___rarg___lambda__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectArray___rarg___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg(lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_renew___rarg___lambda__1(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__5; +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectList(lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +static lean_object* l_Lake_instMonadLogJobM___closed__1; +LEAN_EXPORT lean_object* l_Lake_Job_bindSync(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_pure___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__3(lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobState_renew___boxed(lean_object*); +static lean_object* l_Lake_JobState_log___default___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixArray(lean_object*); +static lean_object* l_Lake_instInhabitedJob___closed__3; +static lean_object* l_Lake_BuildJob_collectList___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_mk(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3(lean_object*); +LEAN_EXPORT uint8_t l_Lake_instDecidableEqJobAction(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_Lake_JobAction_ofNat___boxed(lean_object*); +static lean_object* l_Lake_instMonadStateOfJobStateJobM___closed__1; +static lean_object* l_Lake_instAlternativeJobM___closed__5; +LEAN_EXPORT lean_object* l_Lake_JobState_modifyLog(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeOutJobBundledJob___rarg(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__8; +lean_object* l_Array_push___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_instCoeBundledJob__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_add___rarg(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__24; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMaxJobAction___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instMonadStateOfJobStateJobM___closed__3; +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_collectList___rarg___closed__3; +lean_object* lean_get_set_stdout(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_toJob___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindSync___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_caption___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_as_task(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mk___rarg(lean_object*); +static lean_object* l_Lake_instMonadStateOfLogJobM___closed__3; +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +static lean_object* l_Lake_instInhabitedJob___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_instPure___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadErrorJobM___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_usize_dec_eq(size_t, size_t); +static lean_object* l_Lake_Job_instFunctor___closed__3; +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectList___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync(lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_collectArray___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_Job_setCaption_x3f___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3___rarg(lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mk___rarg___boxed(lean_object*); +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___closed__1; +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_ofTask___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMinJobAction___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__2(lean_object*); +static lean_object* l_Lake_BuildJob_collectArray___rarg___closed__2; +LEAN_EXPORT lean_object* l_Lake_Job_renew___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instOrdJobAction; +static lean_object* l_Lake_JobAction_noConfusion___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_Job_setCaption___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadErrorJobM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindSync___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_await(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixArray___rarg___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instAlternativeJobM___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_mixList___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_map(lean_object*, lean_object*); +lean_object* lean_task_bind(lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_Job_error___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mapWithTrace(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectArray(lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobAction_verb(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_Lake_instInhabitedJob(lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeGet___boxed(lean_object*); +static lean_object* l_Lake_instAlternativeJobM___closed__3; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__2(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_bindSync___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildTrace_mix(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_async(lean_object*); +uint8_t lean_string_validate_utf8(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindTask___rarg___lambda__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_wait_x3f(lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__2; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Job_instFunctor___closed__1; +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync(lean_object*, lean_object*); +static lean_object* l_Lake_JobAction_verb___closed__1; +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_caption(lean_object*); +static lean_object* l_Lake_BuildJob_mixList___rarg___closed__2; +size_t lean_usize_of_nat(lean_object*); +uint8_t l_String_isEmpty(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadErrorJobM(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lake_instMaxJobAction(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__2(lean_object*); +lean_object* lean_task_pure(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__4; +LEAN_EXPORT lean_object* l_Lake_pushLogEntry___at_Lake_instMonadLogJobM___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_toJob(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeDepOpaqueJobJobType___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindTask(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_nil___closed__3; +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_add___rarg___lambda__2(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__18; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1; +static lean_object* l_Lake_instMonadStateOfLogJobM___closed__2; +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_nat_dec_eq(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_ofJob(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_bindSync___spec__4(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixList___rarg(lean_object*); +static lean_object* l_Lake_instOrdJobAction___closed__1; +lean_object* lean_nat_to_int(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__15; +extern lean_object* l_ByteArray_empty; +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__20; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_ofJob___lambda__1(lean_object*); +static lean_object* l_Lake_instReprJobAction___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_mapWithTrace___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobAction_toCtorIdx___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_instFunctor___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg(lean_object*, size_t, size_t, lean_object*); +static lean_object* l_Lake_Job_instFunctor___closed__2; +LEAN_EXPORT lean_object* l_Lake_BuildJob_mapWithTrace___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_instMonadStateOfJobStateJobM___closed__2; +LEAN_EXPORT lean_object* l_Lake_Job_nop(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_instPure(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__16; +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectArray___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__14; +lean_object* l_ReaderT_instMonadLift(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_ofTask(lean_object*); +static lean_object* l_Lake_BuildJob_instFunctor___closed__2; +static lean_object* l_Lake_BuildJob_nil___closed__2; +lean_object* l_Function_const___rarg___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_collectArray___rarg___closed__3; +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___lambda__2(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_st_ref_get(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___lambda__2(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__17; +lean_object* lean_st_mk_ref(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); +LEAN_EXPORT uint8_t l___private_Lake_Build_Job_0__Lake_ordJobAction____x40_Lake_Build_Job___hyg_269_(uint8_t, uint8_t); +lean_object* l_ReaderT_instApplicativeOfMonad___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_pure___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_pure(lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobState_merge(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_wait_x3f___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindTask___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* lean_io_map_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_panic___at_String_fromUTF8_x21___spec__1(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18_(uint8_t, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__9; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_setCaption(lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeMk(lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobAction_verb___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_async___spec__4(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__5(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync(lean_object*, lean_object*); +static lean_object* l_Lake_instMonadStateOfLogJobM___closed__1; +static lean_object* l_Lake_BuildJob_instFunctor___closed__3; +extern lean_object* l_Task_Priority_default; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_instMonadStateOfOfMonadLift___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_instInhabitedJob___closed__2; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__3; +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__12; +static lean_object* l_Lake_BuildJob_ofJob___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_add___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_instPure(lean_object*); +static lean_object* l_Lake_BuildJob_instFunctor___closed__1; +lean_object* l_IO_FS_Stream_ofBuffer(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_wait(lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg(uint8_t, uint8_t, lean_object*); +extern lean_object* l_instMonadBaseIO; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__6(lean_object*); +lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeDepOpaqueJobJobType(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__6(lean_object*); +static lean_object* l_Lake_BuildJob_mixList___rarg___closed__1; +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__19; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_mixList___rarg___closed__3; +extern lean_object* l_Lake_BuildTrace_nil; +LEAN_EXPORT lean_object* l_Lake_instInhabitedBundledJob; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +lean_object* lean_get_set_stderr(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__2; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_EResult_map___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instLTJobAction; +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIOJobM___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_from_utf8(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__23; +LEAN_EXPORT lean_object* l_Lake_BuildJob_map(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_map___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_task(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__3(lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_JobAction_verb___closed__2; +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_instInhabitedOfBundledJob(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_zipWith(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6; +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_async___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeOutJobBundledJob___rarg___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instDecidableEqJobAction___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instAlternativeJobM; +LEAN_EXPORT uint8_t l_Lake_instMinJobAction(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_Lake_Job_instFunctor; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_map___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_setCaption_x3f(lean_object*); +LEAN_EXPORT lean_object* l_Lake_pushLogEntry___at_Lake_instMonadLogJobM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Job_0__Lake_ordJobAction____x40_Lake_Build_Job___hyg_269____boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobState_renew(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_instInhabited___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_mapResult(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIOJobM(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_mapResult___rarg(lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_toJob___rarg___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_instFunctor___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg(lean_object*, size_t, size_t, lean_object*); +uint8_t lean_nat_dec_eq(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lake_instInhabitedJobAction; +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__11; +LEAN_EXPORT lean_object* l_Lake_JobAction_merge___boxed(lean_object*, lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_collectList___rarg___closed__4; +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIOJobM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_mixArray___rarg___closed__1; +static lean_object* l_Lake_JobAction_verb___closed__4; +static lean_object* l_Lake_BuildJob_nil___closed__1; +static lean_object* l_Lake_Job_async___rarg___lambda__2___closed__1; +LEAN_EXPORT lean_object* l_Lake_Job_instInhabited(lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__7; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg(lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeOutJobBundledJob(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_BuildJob_bindSync___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixArray___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLakeMBuildTOfPure___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_shrink___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_instFunctor___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindSync___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__5(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6___rarg(lean_object*, size_t, size_t, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__1; +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__13; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_wait_x3f___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_instDecidableRelLe___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_collectList___rarg___closed__2; +LEAN_EXPORT lean_object* l_Lake_BuildJob_add(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_instFunctor; +lean_object* l_Repr_addAppParen(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobAction_toCtorIdx(uint8_t); +LEAN_EXPORT lean_object* l_Lake_Job_map___rarg(lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instLEJobAction; +LEAN_EXPORT lean_object* l_Lake_Job_pure(lean_object*); +lean_object* lean_task_map(lean_object*, lean_object*, lean_object*, uint8_t); +static lean_object* l_Lake_instAlternativeJobM___closed__4; +static lean_object* l_Lake_JobAction_verb___closed__6; +static lean_object* l_Lake_BuildJob_mixArray___rarg___closed__2; +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_BuildJob_bindSync___spec__4(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobState_log___default; +lean_object* lean_io_bind_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +lean_object* lean_get_set_stdin(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLogJobM; +static lean_object* l_Lake_JobAction_verb___closed__5; +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_OpaqueJob_instCoeBundledJob__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeGet(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__3(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___lambda__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT uint8_t l_Lake_JobAction_merge(uint8_t, uint8_t); +static lean_object* l_Lake_JobAction_verb___closed__8; +LEAN_EXPORT lean_object* l_Lake_instAlternativeJobM___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_toJob(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLakeMBuildTOfPure(lean_object*); +static lean_object* l_Lake_JobAction_verb___closed__3; +LEAN_EXPORT lean_object* l_Lake_Job_renew(lean_object*); +size_t lean_usize_sub(size_t, size_t); +static lean_object* l_Lake_BuildJob_collectArray___rarg___closed__4; +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___lambda__2(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +LEAN_EXPORT uint8_t l_Lake_JobAction_ofNat(lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__22; +static lean_object* l_Lake_JobAction_verb___closed__7; +LEAN_EXPORT lean_object* l_Lake_updateAction(uint8_t, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeMk___boxed(lean_object*); +size_t lean_usize_add(size_t, size_t); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_instInhabitedOfBundledJob___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_instFunctor___lambda__2(lean_object*, lean_object*); +lean_object* l_Lake_EStateT_instMonadStateOfOfPure___rarg(lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_instFunctor___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__21; +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg___lambda__1(lean_object*); +lean_object* lean_array_uget(lean_object*, size_t); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__26; +LEAN_EXPORT lean_object* l_Lake_instReprJobAction; +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3; +static lean_object* l_Lake_Job_renew___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_Job_error(lean_object*); +static lean_object* l_Lake_BuildJob_ofJob___closed__2; +LEAN_EXPORT uint8_t l_Lake_JobState_action___default; +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_toJob___boxed(lean_object*); +static lean_object* l_Lake_instAlternativeJobM___closed__2; +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_mixList___spec__1___rarg(lean_object*, lean_object*); +lean_object* l_List_redLength___rarg(lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_await___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixList(lean_object*); +LEAN_EXPORT lean_object* l_Lake_updateAction___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +lean_object* lean_io_wait(lean_object*, lean_object*); +static lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith___rarg___lambda__2(lean_object*, lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_wait_x3f(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__25; +lean_object* l_Lake_EStateT_instMonad___rarg(lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__10; +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__5(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_mapResult___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_nat_add(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___at_Lake_BuildJob_collectList___spec__4___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_nil; +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_map___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__6(lean_object*); +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_instCoeBundledJob; +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instAlternativeJobM___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_bindTask___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instInhabitedJobState___closed__1; +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_task___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Job_wait___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instInhabitedJob___closed__4; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___at_Lake_BuildJob_collectList___spec__4(lean_object*); +static lean_object* l_Lake_instAlternativeJobM___closed__1; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__4; +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix___rarg___lambda__2(lean_object*, lean_object*); +static lean_object* l_Lake_BuildJob_nil___closed__4; +lean_object* l_List_toArrayAux___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfJobStateJobM; +LEAN_EXPORT lean_object* l_Lake_Job_instPure___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instInhabitedJobState; +LEAN_EXPORT lean_object* l_Lake_JobAction_toCtorIdx(uint8_t x_1) { +_start: +{ +switch (x_1) { +case 0: +{ +lean_object* x_2; +x_2 = lean_unsigned_to_nat(0u); +return x_2; +} +case 1: +{ +lean_object* x_3; +x_3 = lean_unsigned_to_nat(1u); +return x_3; +} +case 2: +{ +lean_object* x_4; +x_4 = lean_unsigned_to_nat(2u); +return x_4; +} +default: +{ +lean_object* x_5; +x_5 = lean_unsigned_to_nat(3u); +return x_5; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_toCtorIdx___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = lean_unbox(x_1); +lean_dec(x_1); +x_3 = l_Lake_JobAction_toCtorIdx(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg___lambda__1(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_noConfusion___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_JobAction_noConfusion___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg(uint8_t x_1, uint8_t x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_JobAction_noConfusion___rarg___closed__1; +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_JobAction_noConfusion___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_JobAction_noConfusion___rarg___lambda__1(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_noConfusion___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; uint8_t x_5; lean_object* x_6; +x_4 = lean_unbox(x_1); +lean_dec(x_1); +x_5 = lean_unbox(x_2); +lean_dec(x_2); +x_6 = l_Lake_JobAction_noConfusion___rarg(x_4, x_5, x_3); +return x_6; +} +} +static uint8_t _init_l_Lake_instInhabitedJobAction() { +_start: +{ +uint8_t x_1; +x_1 = 0; +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.JobAction.unknown", 22); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__1; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(2u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__2; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__5() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__4; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__2; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__8() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__7; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.JobAction.replay", 21); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__9; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__10; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__12() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__11; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__10; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__14() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__13; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__15() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.JobAction.fetch", 20); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__16() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__15; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__16; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__18() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__17; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__19() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__16; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__20() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__19; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__21() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.JobAction.build", 20); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__22() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__21; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__23() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__22; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__24() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__23; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__25() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6; +x_2 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__22; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__26() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__25; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18_(uint8_t x_1, lean_object* x_2) { +_start: +{ +switch (x_1) { +case 0: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_unsigned_to_nat(1024u); +x_4 = lean_nat_dec_le(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; +x_5 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__5; +x_6 = l_Repr_addAppParen(x_5, x_2); +return x_6; +} +else +{ +lean_object* x_7; lean_object* x_8; +x_7 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__8; +x_8 = l_Repr_addAppParen(x_7, x_2); +return x_8; +} +} +case 1: +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_unsigned_to_nat(1024u); +x_10 = lean_nat_dec_le(x_9, x_2); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__12; +x_12 = l_Repr_addAppParen(x_11, x_2); +return x_12; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__14; +x_14 = l_Repr_addAppParen(x_13, x_2); +return x_14; +} +} +case 2: +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_unsigned_to_nat(1024u); +x_16 = lean_nat_dec_le(x_15, x_2); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__18; +x_18 = l_Repr_addAppParen(x_17, x_2); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; +x_19 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__20; +x_20 = l_Repr_addAppParen(x_19, x_2); +return x_20; +} +} +default: +{ +lean_object* x_21; uint8_t x_22; +x_21 = lean_unsigned_to_nat(1024u); +x_22 = lean_nat_dec_le(x_21, x_2); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; +x_23 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__24; +x_24 = l_Repr_addAppParen(x_23, x_2); +return x_24; +} +else +{ +lean_object* x_25; lean_object* x_26; +x_25 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__26; +x_26 = l_Repr_addAppParen(x_25, x_2); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18_(x_3, x_2); +lean_dec(x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_instReprJobAction___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instReprJobAction() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instReprJobAction___closed__1; +return x_1; +} +} +LEAN_EXPORT uint8_t l_Lake_JobAction_ofNat(lean_object* x_1) { +_start: +{ +lean_object* x_2; uint8_t x_3; +x_2 = lean_unsigned_to_nat(2u); +x_3 = lean_nat_dec_le(x_2, x_1); +if (x_3 == 0) +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_unsigned_to_nat(0u); +x_5 = lean_nat_dec_eq(x_1, x_4); +if (x_5 == 0) +{ +uint8_t x_6; +x_6 = 1; +return x_6; +} +else +{ +uint8_t x_7; +x_7 = 0; +return x_7; +} +} +else +{ +uint8_t x_8; +x_8 = lean_nat_dec_eq(x_1, x_2); +if (x_8 == 0) +{ +uint8_t x_9; +x_9 = 3; +return x_9; +} +else +{ +uint8_t x_10; +x_10 = 2; +return x_10; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_ofNat___boxed(lean_object* x_1) { +_start: +{ +uint8_t x_2; lean_object* x_3; +x_2 = l_Lake_JobAction_ofNat(x_1); +lean_dec(x_1); +x_3 = lean_box(x_2); +return x_3; +} +} +LEAN_EXPORT uint8_t l_Lake_instDecidableEqJobAction(uint8_t x_1, uint8_t x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = l_Lake_JobAction_toCtorIdx(x_1); +x_4 = l_Lake_JobAction_toCtorIdx(x_2); +x_5 = lean_nat_dec_eq(x_3, x_4); +lean_dec(x_4); +lean_dec(x_3); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_instDecidableEqJobAction___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; uint8_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = lean_unbox(x_2); +lean_dec(x_2); +x_5 = l_Lake_instDecidableEqJobAction(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +LEAN_EXPORT uint8_t l___private_Lake_Build_Job_0__Lake_ordJobAction____x40_Lake_Build_Job___hyg_269_(uint8_t x_1, uint8_t x_2) { +_start: +{ +switch (x_1) { +case 0: +{ +lean_object* x_3; +x_3 = lean_box(x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +x_4 = 1; +return x_4; +} +else +{ +uint8_t x_5; +lean_dec(x_3); +x_5 = 0; +return x_5; +} +} +case 1: +{ +lean_object* x_6; +x_6 = lean_box(x_2); +switch (lean_obj_tag(x_6)) { +case 0: +{ +uint8_t x_7; +x_7 = 2; +return x_7; +} +case 1: +{ +uint8_t x_8; +x_8 = 1; +return x_8; +} +default: +{ +uint8_t x_9; +lean_dec(x_6); +x_9 = 0; +return x_9; +} +} +} +case 2: +{ +lean_object* x_10; +x_10 = lean_box(x_2); +switch (lean_obj_tag(x_10)) { +case 2: +{ +uint8_t x_11; +x_11 = 1; +return x_11; +} +case 3: +{ +uint8_t x_12; +x_12 = 0; +return x_12; +} +default: +{ +uint8_t x_13; +lean_dec(x_10); +x_13 = 2; +return x_13; +} +} +} +default: +{ +lean_object* x_14; +x_14 = lean_box(x_2); +if (lean_obj_tag(x_14) == 3) +{ +uint8_t x_15; +x_15 = 1; +return x_15; +} +else +{ +uint8_t x_16; +lean_dec(x_14); +x_16 = 2; +return x_16; +} +} +} +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Job_0__Lake_ordJobAction____x40_Lake_Build_Job___hyg_269____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; uint8_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = lean_unbox(x_2); +lean_dec(x_2); +x_5 = l___private_Lake_Build_Job_0__Lake_ordJobAction____x40_Lake_Build_Job___hyg_269_(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +static lean_object* _init_l_Lake_instOrdJobAction___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Job_0__Lake_ordJobAction____x40_Lake_Build_Job___hyg_269____boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instOrdJobAction() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instOrdJobAction___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_instLTJobAction() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(0); +return x_1; +} +} +static lean_object* _init_l_Lake_instLEJobAction() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(0); +return x_1; +} +} +LEAN_EXPORT uint8_t l_Lake_instMinJobAction(uint8_t x_1, uint8_t x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_3 = l_Lake_instOrdJobAction; +x_4 = lean_box(x_1); +x_5 = lean_box(x_2); +x_6 = l_instDecidableRelLe___rarg(x_3, x_4, x_5); +if (x_6 == 0) +{ +return x_2; +} +else +{ +return x_1; +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMinJobAction___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; uint8_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = lean_unbox(x_2); +lean_dec(x_2); +x_5 = l_Lake_instMinJobAction(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +LEAN_EXPORT uint8_t l_Lake_instMaxJobAction(uint8_t x_1, uint8_t x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_3 = l_Lake_instOrdJobAction; +x_4 = lean_box(x_1); +x_5 = lean_box(x_2); +x_6 = l_instDecidableRelLe___rarg(x_3, x_4, x_5); +if (x_6 == 0) +{ +return x_1; +} +else +{ +return x_2; +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMaxJobAction___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; uint8_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = lean_unbox(x_2); +lean_dec(x_2); +x_5 = l_Lake_instMaxJobAction(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +LEAN_EXPORT uint8_t l_Lake_JobAction_merge(uint8_t x_1, uint8_t x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_3 = l_Lake_instOrdJobAction; +x_4 = lean_box(x_1); +x_5 = lean_box(x_2); +x_6 = l_instDecidableRelLe___rarg(x_3, x_4, x_5); +if (x_6 == 0) +{ +return x_1; +} +else +{ +return x_2; +} +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_merge___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; uint8_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = lean_unbox(x_2); +lean_dec(x_2); +x_5 = l_Lake_JobAction_merge(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Ran", 3); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Running", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Replayed", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Replaying", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Fetched", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Fetching", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Built", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_JobAction_verb___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Building", 8); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_verb(uint8_t x_1, uint8_t x_2) { +_start: +{ +switch (x_2) { +case 0: +{ +if (x_1 == 0) +{ +lean_object* x_3; +x_3 = l_Lake_JobAction_verb___closed__1; +return x_3; +} +else +{ +lean_object* x_4; +x_4 = l_Lake_JobAction_verb___closed__2; +return x_4; +} +} +case 1: +{ +if (x_1 == 0) +{ +lean_object* x_5; +x_5 = l_Lake_JobAction_verb___closed__3; +return x_5; +} +else +{ +lean_object* x_6; +x_6 = l_Lake_JobAction_verb___closed__4; +return x_6; +} +} +case 2: +{ +if (x_1 == 0) +{ +lean_object* x_7; +x_7 = l_Lake_JobAction_verb___closed__5; +return x_7; +} +else +{ +lean_object* x_8; +x_8 = l_Lake_JobAction_verb___closed__6; +return x_8; +} +} +default: +{ +if (x_1 == 0) +{ +lean_object* x_9; +x_9 = l_Lake_JobAction_verb___closed__7; +return x_9; +} +else +{ +lean_object* x_10; +x_10 = l_Lake_JobAction_verb___closed__8; +return x_10; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_JobAction_verb___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; uint8_t x_4; lean_object* x_5; +x_3 = lean_unbox(x_1); +lean_dec(x_1); +x_4 = lean_unbox(x_2); +lean_dec(x_2); +x_5 = l_Lake_JobAction_verb(x_3, x_4); +return x_5; +} +} +static lean_object* _init_l_Lake_JobState_log___default___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_JobState_log___default() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_JobState_log___default___closed__1; +return x_1; +} +} +static uint8_t _init_l_Lake_JobState_action___default() { +_start: +{ +uint8_t x_1; +x_1 = 0; +return x_1; +} +} +static lean_object* _init_l_Lake_instInhabitedJobState___closed__1() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l_Lake_JobState_log___default___closed__1; +x_2 = 0; +x_3 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instInhabitedJobState() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instInhabitedJobState___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_JobState_renew(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_instInhabitedJobState___closed__1; +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_JobState_renew___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_JobState_renew(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_JobState_merge(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; uint8_t x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get_uint8(x_1, sizeof(void*)*1); +lean_dec(x_1); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); +x_8 = l_Array_append___rarg(x_3, x_6); +lean_dec(x_6); +x_9 = l_Lake_instOrdJobAction; +x_10 = lean_box(x_4); +x_11 = lean_box(x_7); +x_12 = l_instDecidableRelLe___rarg(x_9, x_10, x_11); +if (x_12 == 0) +{ +lean_ctor_set(x_2, 0, x_8); +lean_ctor_set_uint8(x_2, sizeof(void*)*1, x_4); +return x_2; +} +else +{ +lean_ctor_set(x_2, 0, x_8); +return x_2; +} +} +else +{ +lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; +x_13 = lean_ctor_get(x_2, 0); +x_14 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); +lean_inc(x_13); +lean_dec(x_2); +x_15 = l_Array_append___rarg(x_3, x_13); +lean_dec(x_13); +x_16 = l_Lake_instOrdJobAction; +x_17 = lean_box(x_4); +x_18 = lean_box(x_14); +x_19 = l_instDecidableRelLe___rarg(x_16, x_17, x_18); +if (x_19 == 0) +{ +lean_object* x_20; +x_20 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_20, 0, x_15); +lean_ctor_set_uint8(x_20, sizeof(void*)*1, x_4); +return x_20; +} +else +{ +lean_object* x_21; +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_15); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_14); +return x_21; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_JobState_modifyLog(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_apply_1(x_1, x_4); +lean_ctor_set(x_2, 0, x_5); +return x_2; +} +else +{ +lean_object* x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); +lean_inc(x_6); +lean_dec(x_2); +x_8 = lean_apply_1(x_1, x_6); +x_9 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set_uint8(x_9, sizeof(void*)*1, x_7); +return x_9; +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLakeMBuildTOfPure___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_4, 1); +lean_inc(x_5); +lean_dec(x_4); +x_6 = lean_apply_1(x_3, x_5); +x_7 = lean_apply_2(x_1, lean_box(0), x_6); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLakeMBuildTOfPure(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_instMonadLiftLakeMBuildTOfPure___rarg), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_2, 0); +lean_inc(x_4); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_2); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_3, 0); +lean_dec(x_6); +lean_ctor_set(x_3, 0, x_1); +x_7 = lean_box(0); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_3); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_4); +return x_9; +} +else +{ +uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_dec(x_3); +x_11 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_11, 0, x_1); +lean_ctor_set_uint8(x_11, sizeof(void*)*1, x_10); +x_12 = lean_box(0); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_4); +return x_14; +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; uint8_t x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = lean_apply_1(x_2, x_7); +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_8, 1); +lean_ctor_set(x_4, 0, x_10); +lean_ctor_set(x_8, 1, x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_8); +lean_ctor_set(x_11, 1, x_5); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_8, 0); +x_13 = lean_ctor_get(x_8, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_8); +lean_ctor_set(x_4, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_4); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_5); +return x_15; +} +} +else +{ +lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_16 = lean_ctor_get(x_4, 0); +x_17 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_16); +lean_dec(x_4); +x_18 = lean_apply_1(x_2, x_16); +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_18, 1); +lean_inc(x_20); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_21 = x_18; +} else { + lean_dec_ref(x_18); + x_21 = lean_box(0); +} +x_22 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set_uint8(x_22, sizeof(void*)*1, x_17); +if (lean_is_scalar(x_21)) { + x_23 = lean_alloc_ctor(0, 2, 0); +} else { + x_23 = x_21; +} +lean_ctor_set(x_23, 0, x_19); +lean_ctor_set(x_23, 1, x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_5); +return x_24; +} +} +} +static lean_object* _init_l_Lake_instMonadStateOfLogJobM___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instMonadStateOfLogJobM___lambda__1___boxed), 3, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instMonadStateOfLogJobM___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instMonadStateOfLogJobM___lambda__2___boxed), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instMonadStateOfLogJobM___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instMonadStateOfLogJobM___lambda__3___boxed), 5, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instMonadStateOfLogJobM___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_instMonadStateOfLogJobM___closed__1; +x_2 = l_Lake_instMonadStateOfLogJobM___closed__2; +x_3 = l_Lake_instMonadStateOfLogJobM___closed__3; +x_4 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_instMonadStateOfLogJobM() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instMonadStateOfLogJobM___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_instMonadStateOfLogJobM___lambda__1(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_instMonadStateOfLogJobM___lambda__2(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadStateOfLogJobM___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_instMonadStateOfLogJobM___lambda__3(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +return x_6; +} +} +static lean_object* _init_l_Lake_instMonadStateOfJobStateJobM___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_ReaderT_instMonadLift), 3, 2); +lean_closure_set(x_1, 0, lean_box(0)); +lean_closure_set(x_1, 1, lean_box(0)); +return x_1; +} +} +static lean_object* _init_l_Lake_instMonadStateOfJobStateJobM___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_instMonadBaseIO; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = lean_ctor_get(x_2, 1); +lean_inc(x_3); +lean_dec(x_2); +x_4 = l_Lake_EStateT_instMonadStateOfOfPure___rarg(x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_instMonadStateOfJobStateJobM___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_instMonadStateOfJobStateJobM___closed__1; +x_2 = l_Lake_instMonadStateOfJobStateJobM___closed__2; +x_3 = l_instMonadStateOfOfMonadLift___rarg(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instMonadStateOfJobStateJobM() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instMonadStateOfJobStateJobM___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_pushLogEntry___at_Lake_instMonadLogJobM___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_3, 0); +x_7 = lean_array_push(x_6, x_1); +lean_ctor_set(x_3, 0, x_7); +x_8 = lean_box(0); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_3); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_4); +return x_10; +} +else +{ +lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_11 = lean_ctor_get(x_3, 0); +x_12 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_11); +lean_dec(x_3); +x_13 = lean_array_push(x_11, x_1); +x_14 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set_uint8(x_14, sizeof(void*)*1, x_12); +x_15 = lean_box(0); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_14); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_4); +return x_17; +} +} +} +static lean_object* _init_l_Lake_instMonadLogJobM___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_pushLogEntry___at_Lake_instMonadLogJobM___spec__1___boxed), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instMonadLogJobM() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instMonadLogJobM___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_pushLogEntry___at_Lake_instMonadLogJobM___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_pushLogEntry___at_Lake_instMonadLogJobM___spec__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadErrorJobM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; uint8_t x_7; +x_5 = 3; +x_6 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set_uint8(x_6, sizeof(void*)*1, x_5); +x_7 = !lean_is_exclusive(x_3); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_8 = lean_ctor_get(x_3, 0); +x_9 = lean_array_get_size(x_8); +x_10 = lean_array_push(x_8, x_6); +lean_ctor_set(x_3, 0, x_10); +x_11 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_11, 0, x_9); +lean_ctor_set(x_11, 1, x_3); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_4); +return x_12; +} +else +{ +lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_13 = lean_ctor_get(x_3, 0); +x_14 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_13); +lean_dec(x_3); +x_15 = lean_array_get_size(x_13); +x_16 = lean_array_push(x_13, x_6); +x_17 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set_uint8(x_17, sizeof(void*)*1, x_14); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_15); +lean_ctor_set(x_18, 1, x_17); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_4); +return x_19; +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadErrorJobM(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_instMonadErrorJobM___rarg___boxed), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadErrorJobM___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_instMonadErrorJobM___rarg(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_instAlternativeJobM___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = lean_array_get_size(x_5); +lean_dec(x_5); +x_7 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_4); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_instAlternativeJobM___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +lean_inc(x_4); +x_7 = lean_apply_3(x_2, x_4, x_5, x_6); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +lean_dec(x_4); +lean_dec(x_3); +x_9 = !lean_is_exclusive(x_7); +if (x_9 == 0) +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_7, 0); +lean_dec(x_10); +return x_7; +} +else +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_7, 1); +lean_inc(x_11); +lean_dec(x_7); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_8); +lean_ctor_set(x_12, 1, x_11); +return x_12; +} +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_13 = lean_ctor_get(x_8, 1); +lean_inc(x_13); +x_14 = lean_ctor_get(x_7, 1); +lean_inc(x_14); +lean_dec(x_7); +x_15 = lean_ctor_get(x_8, 0); +lean_inc(x_15); +lean_dec(x_8); +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_17 = lean_ctor_get(x_13, 0); +x_18 = l_Array_shrink___rarg(x_17, x_15); +lean_dec(x_15); +lean_ctor_set(x_13, 0, x_18); +x_19 = lean_box(0); +x_20 = lean_apply_4(x_3, x_19, x_4, x_13, x_14); +return x_20; +} +else +{ +lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_21 = lean_ctor_get(x_13, 0); +x_22 = lean_ctor_get_uint8(x_13, sizeof(void*)*1); +lean_inc(x_21); +lean_dec(x_13); +x_23 = l_Array_shrink___rarg(x_21, x_15); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set_uint8(x_24, sizeof(void*)*1, x_22); +x_25 = lean_box(0); +x_26 = lean_apply_4(x_3, x_25, x_4, x_24, x_14); +return x_26; +} +} +} +else +{ +uint8_t x_27; +lean_dec(x_4); +lean_dec(x_3); +x_27 = !lean_is_exclusive(x_7); +if (x_27 == 0) +{ +return x_7; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_7, 0); +x_29 = lean_ctor_get(x_7, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_7); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +return x_30; +} +} +} +} +static lean_object* _init_l_Lake_instAlternativeJobM___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_instMonadBaseIO; +x_2 = l_Lake_EStateT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instAlternativeJobM___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_instAlternativeJobM___closed__1; +x_2 = l_ReaderT_instApplicativeOfMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instAlternativeJobM___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instAlternativeJobM___lambda__1___boxed), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instAlternativeJobM___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instAlternativeJobM___lambda__2), 6, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instAlternativeJobM___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_instAlternativeJobM___closed__2; +x_2 = l_Lake_instAlternativeJobM___closed__3; +x_3 = l_Lake_instAlternativeJobM___closed__4; +x_4 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_2); +lean_ctor_set(x_4, 2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_instAlternativeJobM() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instAlternativeJobM___closed__5; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instAlternativeJobM___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_instAlternativeJobM___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIOJobM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_3, 0); +x_7 = lean_apply_2(x_1, x_6, x_4); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_7); +if (x_9 == 0) +{ +lean_object* x_10; uint8_t x_11; +x_10 = lean_ctor_get(x_7, 0); +lean_dec(x_10); +x_11 = !lean_is_exclusive(x_8); +if (x_11 == 0) +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_8, 1); +lean_ctor_set(x_3, 0, x_12); +lean_ctor_set(x_8, 1, x_3); +return x_7; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = lean_ctor_get(x_8, 0); +x_14 = lean_ctor_get(x_8, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_8); +lean_ctor_set(x_3, 0, x_14); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_3); +lean_ctor_set(x_7, 0, x_15); +return x_7; +} +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_7, 1); +lean_inc(x_16); +lean_dec(x_7); +x_17 = lean_ctor_get(x_8, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_8, 1); +lean_inc(x_18); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + lean_ctor_release(x_8, 1); + x_19 = x_8; +} else { + lean_dec_ref(x_8); + x_19 = lean_box(0); +} +lean_ctor_set(x_3, 0, x_18); +if (lean_is_scalar(x_19)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_19; +} +lean_ctor_set(x_20, 0, x_17); +lean_ctor_set(x_20, 1, x_3); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_16); +return x_21; +} +} +else +{ +uint8_t x_22; +x_22 = !lean_is_exclusive(x_7); +if (x_22 == 0) +{ +lean_object* x_23; uint8_t x_24; +x_23 = lean_ctor_get(x_7, 0); +lean_dec(x_23); +x_24 = !lean_is_exclusive(x_8); +if (x_24 == 0) +{ +lean_object* x_25; +x_25 = lean_ctor_get(x_8, 1); +lean_ctor_set(x_3, 0, x_25); +lean_ctor_set(x_8, 1, x_3); +return x_7; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_8, 0); +x_27 = lean_ctor_get(x_8, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_8); +lean_ctor_set(x_3, 0, x_27); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_3); +lean_ctor_set(x_7, 0, x_28); +return x_7; +} +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_29 = lean_ctor_get(x_7, 1); +lean_inc(x_29); +lean_dec(x_7); +x_30 = lean_ctor_get(x_8, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_8, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + lean_ctor_release(x_8, 1); + x_32 = x_8; +} else { + lean_dec_ref(x_8); + x_32 = lean_box(0); +} +lean_ctor_set(x_3, 0, x_31); +if (lean_is_scalar(x_32)) { + x_33 = lean_alloc_ctor(1, 2, 0); +} else { + x_33 = x_32; +} +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_3); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_29); +return x_34; +} +} +} +else +{ +uint8_t x_35; +lean_free_object(x_3); +x_35 = !lean_is_exclusive(x_7); +if (x_35 == 0) +{ +return x_7; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_7, 0); +x_37 = lean_ctor_get(x_7, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_7); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +return x_38; +} +} +} +else +{ +lean_object* x_39; uint8_t x_40; lean_object* x_41; +x_39 = lean_ctor_get(x_3, 0); +x_40 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_39); +lean_dec(x_3); +x_41 = lean_apply_2(x_1, x_39, x_4); +if (lean_obj_tag(x_41) == 0) +{ +lean_object* x_42; +x_42 = lean_ctor_get(x_41, 0); +lean_inc(x_42); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_43 = lean_ctor_get(x_41, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_44 = x_41; +} else { + lean_dec_ref(x_41); + x_44 = lean_box(0); +} +x_45 = lean_ctor_get(x_42, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_42, 1); +lean_inc(x_46); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_47 = x_42; +} else { + lean_dec_ref(x_42); + x_47 = lean_box(0); +} +x_48 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set_uint8(x_48, sizeof(void*)*1, x_40); +if (lean_is_scalar(x_47)) { + x_49 = lean_alloc_ctor(0, 2, 0); +} else { + x_49 = x_47; +} +lean_ctor_set(x_49, 0, x_45); +lean_ctor_set(x_49, 1, x_48); +if (lean_is_scalar(x_44)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_44; +} +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_43); +return x_50; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_51 = lean_ctor_get(x_41, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_52 = x_41; +} else { + lean_dec_ref(x_41); + x_52 = lean_box(0); +} +x_53 = lean_ctor_get(x_42, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_42, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_55 = x_42; +} else { + lean_dec_ref(x_42); + x_55 = lean_box(0); +} +x_56 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set_uint8(x_56, sizeof(void*)*1, x_40); +if (lean_is_scalar(x_55)) { + x_57 = lean_alloc_ctor(1, 2, 0); +} else { + x_57 = x_55; +} +lean_ctor_set(x_57, 0, x_53); +lean_ctor_set(x_57, 1, x_56); +if (lean_is_scalar(x_52)) { + x_58 = lean_alloc_ctor(0, 2, 0); +} else { + x_58 = x_52; +} +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_51); +return x_58; +} +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_59 = lean_ctor_get(x_41, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_41, 1); +lean_inc(x_60); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_61 = x_41; +} else { + lean_dec_ref(x_41); + x_61 = lean_box(0); +} +if (lean_is_scalar(x_61)) { + x_62 = lean_alloc_ctor(1, 2, 0); +} else { + x_62 = x_61; +} +lean_ctor_set(x_62, 0, x_59); +lean_ctor_set(x_62, 1, x_60); +return x_62; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIOJobM(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_instMonadLiftLogIOJobM___rarg___boxed), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instMonadLiftLogIOJobM___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_instMonadLiftLogIOJobM___rarg(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_updateAction(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_6 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +x_7 = l_Lake_instOrdJobAction; +x_8 = lean_box(x_6); +x_9 = lean_box(x_1); +x_10 = l_instDecidableRelLe___rarg(x_7, x_8, x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_box(0); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_3); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_4); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1); +x_14 = lean_box(0); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_3); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_4); +return x_16; +} +} +else +{ +lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_17 = lean_ctor_get(x_3, 0); +x_18 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_17); +lean_dec(x_3); +x_19 = l_Lake_instOrdJobAction; +x_20 = lean_box(x_18); +x_21 = lean_box(x_1); +x_22 = l_instDecidableRelLe___rarg(x_19, x_20, x_21); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_23, 0, x_17); +lean_ctor_set_uint8(x_23, sizeof(void*)*1, x_18); +x_24 = lean_box(0); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_23); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_4); +return x_26; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_27 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_27, 0, x_17); +lean_ctor_set_uint8(x_27, sizeof(void*)*1, x_1); +x_28 = lean_box(0); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_4); +return x_30; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_updateAction___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_1); +lean_dec(x_1); +x_6 = l_Lake_updateAction(x_5, x_2, x_3, x_4); +lean_dec(x_2); +return x_6; +} +} +static lean_object* _init_l_Lake_instInhabitedJob___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_unsigned_to_nat(0u); +x_2 = l_Lake_instInhabitedJobState___closed__1; +x_3 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instInhabitedJob___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_instInhabitedJob___closed__1; +x_2 = lean_task_pure(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instInhabitedJob___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instInhabitedJob___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_instInhabitedJob___closed__2; +x_2 = l_Lake_instInhabitedJob___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instInhabitedJob(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_instInhabitedJob___closed__4; +return x_2; +} +} +static lean_object* _init_l_Lake_instInhabitedBundledJob() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instInhabitedJob___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeOutJobBundledJob___rarg(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeOutJobBundledJob(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_instCoeOutJobBundledJob___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeOutJobBundledJob___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_instCoeOutJobBundledJob___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeMk(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeMk___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_OpaqueJob_unsafeMk(x_1); +lean_dec(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_OpaqueJob_instCoeBundledJob___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_OpaqueJob_unsafeMk___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_OpaqueJob_instCoeBundledJob() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_OpaqueJob_instCoeBundledJob___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeGet(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_unsafeGet___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_OpaqueJob_unsafeGet(x_1); +lean_dec(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_OpaqueJob_instCoeBundledJob__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_OpaqueJob_unsafeGet___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_OpaqueJob_instCoeBundledJob__1() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_OpaqueJob_instCoeBundledJob__1___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_instInhabitedOfBundledJob(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_instInhabitedOfBundledJob___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_OpaqueJob_instInhabitedOfBundledJob(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_toJob(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_toJob___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_OpaqueJob_toJob(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_task(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_task___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_OpaqueJob_task(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_caption(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_ctor_get(x_1, 1); +lean_inc(x_2); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_OpaqueJob_caption___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_OpaqueJob_caption(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeDepOpaqueJobJobType(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeDepOpaqueJobJobType___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_instCoeDepOpaqueJobJobType(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_ofTask___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_ofTask(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_ofTask___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_error___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_3 = 0; +x_4 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set_uint8(x_4, sizeof(void*)*1, x_3); +x_5 = lean_unsigned_to_nat(0u); +x_6 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +x_7 = lean_task_pure(x_6); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_error(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_error___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_pure___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_4 = 0; +x_5 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_5, 0, x_2); +lean_ctor_set_uint8(x_5, sizeof(void*)*1, x_4); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_5); +x_7 = lean_task_pure(x_6); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_3); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_pure(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_pure___rarg), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_instPure___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_2 = l_Lake_instInhabitedJobState___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +x_4 = lean_task_pure(x_3); +x_5 = l_Lake_instInhabitedJob___closed__3; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_4); +lean_ctor_set(x_6, 1, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_instPure(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_instPure___rarg), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_instInhabited___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_2 = l_Lake_instInhabitedJobState___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +x_4 = lean_task_pure(x_3); +x_5 = l_Lake_instInhabitedJob___closed__3; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_4); +lean_ctor_set(x_6, 1, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_instInhabited(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_instInhabited___rarg), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_nop(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_3 = 0; +x_4 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set_uint8(x_4, sizeof(void*)*1, x_3); +x_5 = lean_box(0); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_4); +x_7 = lean_task_pure(x_6); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_setCaption___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; +x_4 = lean_ctor_get(x_2, 1); +lean_dec(x_4); +lean_ctor_set(x_2, 1, x_1); +return x_2; +} +else +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +lean_dec(x_2); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_1); +return x_6; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_setCaption(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_setCaption___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_setCaption_x3f___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_ctor_get(x_2, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_2, 1); +lean_inc(x_4); +x_5 = l_String_isEmpty(x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_3); +lean_dec(x_1); +return x_2; +} +else +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_2); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; +x_7 = lean_ctor_get(x_2, 1); +lean_dec(x_7); +x_8 = lean_ctor_get(x_2, 0); +lean_dec(x_8); +lean_ctor_set(x_2, 1, x_1); +return x_2; +} +else +{ +lean_object* x_9; +lean_dec(x_2); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_3); +lean_ctor_set(x_9, 1, x_1); +return x_9; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_setCaption_x3f(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_setCaption_x3f___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_mapResult___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_task_map(x_1, x_6, x_3, x_4); +lean_ctor_set(x_2, 0, x_7); +return x_2; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_2, 0); +x_9 = lean_ctor_get(x_2, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_2); +x_10 = lean_task_map(x_1, x_8, x_3, x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_9); +return x_11; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_mapResult(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_Job_mapResult___rarg___boxed), 4, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_mapResult___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_4); +lean_dec(x_4); +x_6 = l_Lake_Job_mapResult___rarg(x_1, x_2, x_3, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindTask___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = lean_ctor_get(x_4, 1); +lean_inc(x_5); +lean_dec(x_4); +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_3); +lean_ctor_set(x_7, 1, x_6); +x_8 = lean_apply_2(x_5, lean_box(0), x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindTask___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = lean_apply_1(x_2, x_5); +x_7 = lean_alloc_closure((void*)(l_Lake_Job_bindTask___rarg___lambda__1___boxed), 3, 2); +lean_closure_set(x_7, 0, x_1); +lean_closure_set(x_7, 1, x_3); +x_8 = lean_apply_4(x_4, lean_box(0), lean_box(0), x_6, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindTask(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_Job_bindTask___rarg), 3, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindTask___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_Job_bindTask___rarg___lambda__1(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_map___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4) { +_start: +{ +lean_object* x_5; uint8_t x_6; +x_5 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_5, 0, x_1); +x_6 = !lean_is_exclusive(x_2); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; +x_7 = lean_ctor_get(x_2, 0); +x_8 = lean_task_map(x_5, x_7, x_3, x_4); +lean_ctor_set(x_2, 0, x_8); +return x_2; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_9 = lean_ctor_get(x_2, 0); +x_10 = lean_ctor_get(x_2, 1); +lean_inc(x_10); +lean_inc(x_9); +lean_dec(x_2); +x_11 = lean_task_map(x_5, x_9, x_3, x_4); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_10); +return x_12; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_map(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_Job_map___rarg___boxed), 4, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_map___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = lean_unbox(x_4); +lean_dec(x_4); +x_6 = l_Lake_Job_map___rarg(x_1, x_2, x_3, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_instFunctor___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; uint8_t x_6; +x_5 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_5, 0, x_3); +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_Task_Priority_default; +x_9 = 0; +x_10 = lean_task_map(x_5, x_7, x_8, x_9); +lean_ctor_set(x_4, 0, x_10); +return x_4; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_4, 0); +x_12 = lean_ctor_get(x_4, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_4); +x_13 = l_Task_Priority_default; +x_14 = 0; +x_15 = lean_task_map(x_5, x_11, x_13, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_12); +return x_16; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_instFunctor___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_5 = lean_alloc_closure((void*)(l_Function_const___rarg___boxed), 2, 1); +lean_closure_set(x_5, 0, x_3); +x_6 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_6, 0, x_5); +x_7 = !lean_is_exclusive(x_4); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_4, 0); +x_9 = l_Task_Priority_default; +x_10 = 0; +x_11 = lean_task_map(x_6, x_8, x_9, x_10); +lean_ctor_set(x_4, 0, x_11); +return x_4; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; +x_12 = lean_ctor_get(x_4, 0); +x_13 = lean_ctor_get(x_4, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_4); +x_14 = l_Task_Priority_default; +x_15 = 0; +x_16 = lean_task_map(x_6, x_12, x_14, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_13); +return x_17; +} +} +} +static lean_object* _init_l_Lake_Job_instFunctor___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Job_instFunctor___lambda__1), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Job_instFunctor___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Job_instFunctor___lambda__2), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Job_instFunctor___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Job_instFunctor___closed__1; +x_2 = l_Lake_Job_instFunctor___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Job_instFunctor() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Job_instFunctor___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_renew___rarg___lambda__1(lean_object* x_1) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 1); +lean_dec(x_3); +x_4 = l_Lake_instInhabitedJobState___closed__1; +lean_ctor_set(x_1, 1, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 0); +lean_inc(x_5); +lean_dec(x_1); +x_6 = l_Lake_instInhabitedJobState___closed__1; +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_5); +lean_ctor_set(x_7, 1, x_6); +return x_7; +} +} +else +{ +lean_object* x_8; +lean_dec(x_1); +x_8 = l_Lake_instInhabitedJob___closed__1; +return x_8; +} +} +} +static lean_object* _init_l_Lake_Job_renew___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Job_renew___rarg___lambda__1), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_renew___rarg(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Lake_Job_renew___rarg___closed__1; +x_5 = l_Task_Priority_default; +x_6 = 1; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Lake_Job_renew___rarg___closed__1; +x_11 = l_Task_Priority_default; +x_12 = 1; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_renew(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_renew___rarg), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_async___spec__2___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Job_async___spec__3___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_async___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_async___spec__4(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Job_async___spec__4___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__5___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_async___spec__5(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_async___spec__5___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_async___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Job_async___spec__6___rarg), 5, 0); +return x_2; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_ByteArray_empty; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Init.Data.String.Extra", 22); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("String.fromUTF8!", 16); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid UTF-8 string", 20); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5() { +_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_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__2; +x_2 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__3; +x_3 = lean_unsigned_to_nat(92u); +x_4 = lean_unsigned_to_nat(47u); +x_5 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__4; +x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_async___spec__2___rarg), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_Job_async___spec__3___rarg(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Job_async___spec__4___rarg), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_async___spec__5___rarg), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_Job_async___spec__6___rarg(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_async___spec__2___rarg), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_Job_async___spec__3___rarg(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Job_async___spec__4___rarg), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_async___spec__5___rarg), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_Job_async___spec__6___rarg(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_4); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +static lean_object* _init_l_Lake_Job_async___rarg___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout/stderr:\n", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = 1; +lean_inc(x_2); +x_6 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg(x_1, x_5, x_2, x_3, x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_ctor_get(x_8, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_8, 1); +lean_inc(x_12); +lean_dec(x_8); +x_13 = l_String_isEmpty(x_11); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; uint8_t x_20; +x_14 = l_Lake_Job_async___rarg___lambda__2___closed__1; +x_15 = lean_string_append(x_14, x_11); +lean_dec(x_11); +x_16 = l_Lake_instInhabitedJob___closed__3; +x_17 = lean_string_append(x_15, x_16); +x_18 = 1; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = !lean_is_exclusive(x_10); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_10, 0); +x_22 = lean_array_push(x_21, x_19); +lean_ctor_set(x_10, 0, x_22); +x_23 = lean_box(0); +x_24 = l_Lake_Job_async___rarg___lambda__1(x_12, x_23, x_2, x_10, x_9); +lean_dec(x_2); +return x_24; +} +else +{ +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 0); +x_26 = lean_ctor_get_uint8(x_10, sizeof(void*)*1); +lean_inc(x_25); +lean_dec(x_10); +x_27 = lean_array_push(x_25, x_19); +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_26); +x_29 = lean_box(0); +x_30 = l_Lake_Job_async___rarg___lambda__1(x_12, x_29, x_2, x_28, x_9); +lean_dec(x_2); +return x_30; +} +} +else +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_11); +x_31 = lean_box(0); +x_32 = l_Lake_Job_async___rarg___lambda__1(x_12, x_31, x_2, x_10, x_9); +lean_dec(x_2); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_dec(x_2); +x_33 = !lean_is_exclusive(x_6); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = lean_ctor_get(x_6, 0); +lean_dec(x_34); +x_35 = !lean_is_exclusive(x_7); +if (x_35 == 0) +{ +return x_6; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_7, 0); +x_37 = lean_ctor_get(x_7, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_7); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +lean_ctor_set(x_6, 0, x_38); +return x_6; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_39 = lean_ctor_get(x_6, 1); +lean_inc(x_39); +lean_dec(x_6); +x_40 = lean_ctor_get(x_7, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_7, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_7)) { + lean_ctor_release(x_7, 0); + lean_ctor_release(x_7, 1); + x_42 = x_7; +} else { + lean_dec_ref(x_7); + x_42 = lean_box(0); +} +if (lean_is_scalar(x_42)) { + x_43 = lean_alloc_ctor(1, 2, 0); +} else { + x_43 = x_42; +} +lean_ctor_set(x_43, 0, x_40); +lean_ctor_set(x_43, 1, x_41); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_39); +return x_44; +} +} +} +else +{ +uint8_t x_45; +lean_dec(x_2); +x_45 = !lean_is_exclusive(x_6); +if (x_45 == 0) +{ +return x_6; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_6, 0); +x_47 = lean_ctor_get(x_6, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_6); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +return x_48; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = l_Lake_instInhabitedJobState___closed__1; +x_6 = lean_alloc_closure((void*)(l_Lake_Job_async___rarg___lambda__2), 4, 3); +lean_closure_set(x_6, 0, x_1); +lean_closure_set(x_6, 1, x_3); +lean_closure_set(x_6, 2, x_5); +x_7 = lean_io_as_task(x_6, x_2, x_4); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_7, 0); +x_10 = l_Lake_instInhabitedJob___closed__3; +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_9); +lean_ctor_set(x_11, 1, x_10); +lean_ctor_set(x_7, 0, x_11); +return x_7; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_7, 0); +x_13 = lean_ctor_get(x_7, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_7); +x_14 = l_Lake_instInhabitedJob___closed__3; +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_12); +lean_ctor_set(x_15, 1, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_13); +return x_16; +} +} +else +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_7); +if (x_17 == 0) +{ +return x_7; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_7, 0); +x_19 = lean_ctor_get(x_7, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_7); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_async(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_async___rarg), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_async___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Job_async___rarg___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_wait___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = lean_io_wait(x_3, x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_wait(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_wait___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_wait_x3f___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = lean_io_wait(x_3, x_2); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +if (lean_obj_tag(x_5) == 0) +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +lean_dec(x_7); +x_8 = lean_ctor_get(x_5, 0); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_4, 0, x_9); +return x_4; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_10 = lean_ctor_get(x_4, 1); +lean_inc(x_10); +lean_dec(x_4); +x_11 = lean_ctor_get(x_5, 0); +lean_inc(x_11); +lean_dec(x_5); +x_12 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_12, 0, x_11); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_10); +return x_13; +} +} +else +{ +uint8_t x_14; +lean_dec(x_5); +x_14 = !lean_is_exclusive(x_4); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_4, 0); +lean_dec(x_15); +x_16 = lean_box(0); +lean_ctor_set(x_4, 0, x_16); +return x_4; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_4, 1); +lean_inc(x_17); +lean_dec(x_4); +x_18 = lean_box(0); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_17); +return x_19; +} +} +} +else +{ +uint8_t x_20; +x_20 = !lean_is_exclusive(x_4); +if (x_20 == 0) +{ +return x_4; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_4, 0); +x_22 = lean_ctor_get(x_4, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_4); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_wait_x3f(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_wait_x3f___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = lean_usize_dec_eq(x_2, x_3); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; size_t x_10; size_t x_11; lean_object* x_12; +lean_dec(x_4); +x_8 = lean_array_uget(x_1, x_2); +x_9 = lean_array_push(x_5, x_8); +x_10 = 1; +x_11 = lean_usize_add(x_2, x_10); +x_12 = lean_box(0); +x_2 = x_11; +x_4 = x_12; +x_5 = x_9; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_4); +lean_ctor_set(x_14, 1, x_5); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_6); +return x_15; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_await___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = lean_io_wait(x_4, x_3); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; uint8_t x_8; +x_7 = lean_ctor_get(x_6, 1); +lean_inc(x_7); +x_8 = !lean_is_exclusive(x_5); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; uint8_t x_11; +x_9 = lean_ctor_get(x_5, 1); +x_10 = lean_ctor_get(x_5, 0); +lean_dec(x_10); +x_11 = !lean_is_exclusive(x_6); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; +x_12 = lean_ctor_get(x_6, 0); +x_13 = lean_ctor_get(x_6, 1); +lean_dec(x_13); +x_14 = lean_ctor_get(x_7, 0); +lean_inc(x_14); +lean_dec(x_7); +x_15 = lean_array_get_size(x_14); +x_16 = lean_unsigned_to_nat(0u); +x_17 = lean_nat_dec_lt(x_16, x_15); +if (x_17 == 0) +{ +lean_dec(x_15); +lean_dec(x_14); +lean_ctor_set(x_6, 1, x_2); +return x_5; +} +else +{ +uint8_t x_18; +x_18 = lean_nat_dec_le(x_15, x_15); +if (x_18 == 0) +{ +lean_dec(x_15); +lean_dec(x_14); +lean_ctor_set(x_6, 1, x_2); +return x_5; +} +else +{ +size_t x_19; size_t x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; +lean_free_object(x_6); +lean_free_object(x_5); +x_19 = 0; +x_20 = lean_usize_of_nat(x_15); +lean_dec(x_15); +x_21 = lean_box(0); +x_22 = l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(x_14, x_19, x_20, x_21, x_2, x_9); +lean_dec(x_14); +x_23 = !lean_is_exclusive(x_22); +if (x_23 == 0) +{ +lean_object* x_24; uint8_t x_25; +x_24 = lean_ctor_get(x_22, 0); +x_25 = !lean_is_exclusive(x_24); +if (x_25 == 0) +{ +lean_object* x_26; +x_26 = lean_ctor_get(x_24, 0); +lean_dec(x_26); +lean_ctor_set(x_24, 0, x_12); +return x_22; +} +else +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_24, 1); +lean_inc(x_27); +lean_dec(x_24); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_12); +lean_ctor_set(x_28, 1, x_27); +lean_ctor_set(x_22, 0, x_28); +return x_22; +} +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_29 = lean_ctor_get(x_22, 0); +x_30 = lean_ctor_get(x_22, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_22); +x_31 = lean_ctor_get(x_29, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_32 = x_29; +} else { + lean_dec_ref(x_29); + x_32 = lean_box(0); +} +if (lean_is_scalar(x_32)) { + x_33 = lean_alloc_ctor(0, 2, 0); +} else { + x_33 = x_32; +} +lean_ctor_set(x_33, 0, x_12); +lean_ctor_set(x_33, 1, x_31); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_30); +return x_34; +} +} +} +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; +x_35 = lean_ctor_get(x_6, 0); +lean_inc(x_35); +lean_dec(x_6); +x_36 = lean_ctor_get(x_7, 0); +lean_inc(x_36); +lean_dec(x_7); +x_37 = lean_array_get_size(x_36); +x_38 = lean_unsigned_to_nat(0u); +x_39 = lean_nat_dec_lt(x_38, x_37); +if (x_39 == 0) +{ +lean_object* x_40; +lean_dec(x_37); +lean_dec(x_36); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_35); +lean_ctor_set(x_40, 1, x_2); +lean_ctor_set(x_5, 0, x_40); +return x_5; +} +else +{ +uint8_t x_41; +x_41 = lean_nat_dec_le(x_37, x_37); +if (x_41 == 0) +{ +lean_object* x_42; +lean_dec(x_37); +lean_dec(x_36); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_35); +lean_ctor_set(x_42, 1, x_2); +lean_ctor_set(x_5, 0, x_42); +return x_5; +} +else +{ +size_t x_43; size_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +lean_free_object(x_5); +x_43 = 0; +x_44 = lean_usize_of_nat(x_37); +lean_dec(x_37); +x_45 = lean_box(0); +x_46 = l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(x_36, x_43, x_44, x_45, x_2, x_9); +lean_dec(x_36); +x_47 = lean_ctor_get(x_46, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_46, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_46)) { + lean_ctor_release(x_46, 0); + lean_ctor_release(x_46, 1); + x_49 = x_46; +} else { + lean_dec_ref(x_46); + x_49 = lean_box(0); +} +x_50 = lean_ctor_get(x_47, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_51 = x_47; +} else { + lean_dec_ref(x_47); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_35); +lean_ctor_set(x_52, 1, x_50); +if (lean_is_scalar(x_49)) { + x_53 = lean_alloc_ctor(0, 2, 0); +} else { + x_53 = x_49; +} +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +return x_53; +} +} +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_54 = lean_ctor_get(x_5, 1); +lean_inc(x_54); +lean_dec(x_5); +x_55 = lean_ctor_get(x_6, 0); +lean_inc(x_55); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + lean_ctor_release(x_6, 1); + x_56 = x_6; +} else { + lean_dec_ref(x_6); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_7, 0); +lean_inc(x_57); +lean_dec(x_7); +x_58 = lean_array_get_size(x_57); +x_59 = lean_unsigned_to_nat(0u); +x_60 = lean_nat_dec_lt(x_59, x_58); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; +lean_dec(x_58); +lean_dec(x_57); +if (lean_is_scalar(x_56)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_56; +} +lean_ctor_set(x_61, 0, x_55); +lean_ctor_set(x_61, 1, x_2); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_54); +return x_62; +} +else +{ +uint8_t x_63; +x_63 = lean_nat_dec_le(x_58, x_58); +if (x_63 == 0) +{ +lean_object* x_64; lean_object* x_65; +lean_dec(x_58); +lean_dec(x_57); +if (lean_is_scalar(x_56)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_56; +} +lean_ctor_set(x_64, 0, x_55); +lean_ctor_set(x_64, 1, x_2); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_54); +return x_65; +} +else +{ +size_t x_66; size_t x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_56); +x_66 = 0; +x_67 = lean_usize_of_nat(x_58); +lean_dec(x_58); +x_68 = lean_box(0); +x_69 = l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(x_57, x_66, x_67, x_68, x_2, x_54); +lean_dec(x_57); +x_70 = lean_ctor_get(x_69, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_69, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_69)) { + lean_ctor_release(x_69, 0); + lean_ctor_release(x_69, 1); + x_72 = x_69; +} else { + lean_dec_ref(x_69); + x_72 = lean_box(0); +} +x_73 = lean_ctor_get(x_70, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_70)) { + lean_ctor_release(x_70, 0); + lean_ctor_release(x_70, 1); + x_74 = x_70; +} else { + lean_dec_ref(x_70); + x_74 = lean_box(0); +} +if (lean_is_scalar(x_74)) { + x_75 = lean_alloc_ctor(0, 2, 0); +} else { + x_75 = x_74; +} +lean_ctor_set(x_75, 0, x_55); +lean_ctor_set(x_75, 1, x_73); +if (lean_is_scalar(x_72)) { + x_76 = lean_alloc_ctor(0, 2, 0); +} else { + x_76 = x_72; +} +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_71); +return x_76; +} +} +} +} +else +{ +lean_object* x_77; uint8_t x_78; +x_77 = lean_ctor_get(x_6, 1); +lean_inc(x_77); +x_78 = !lean_is_exclusive(x_5); +if (x_78 == 0) +{ +lean_object* x_79; lean_object* x_80; uint8_t x_81; +x_79 = lean_ctor_get(x_5, 1); +x_80 = lean_ctor_get(x_5, 0); +lean_dec(x_80); +x_81 = !lean_is_exclusive(x_6); +if (x_81 == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; uint8_t x_87; +x_82 = lean_ctor_get(x_6, 0); +x_83 = lean_ctor_get(x_6, 1); +lean_dec(x_83); +x_84 = lean_ctor_get(x_77, 0); +lean_inc(x_84); +lean_dec(x_77); +x_85 = lean_array_get_size(x_84); +x_86 = lean_unsigned_to_nat(0u); +x_87 = lean_nat_dec_lt(x_86, x_85); +if (x_87 == 0) +{ +lean_dec(x_85); +lean_dec(x_84); +lean_ctor_set(x_6, 1, x_2); +return x_5; +} +else +{ +uint8_t x_88; +x_88 = lean_nat_dec_le(x_85, x_85); +if (x_88 == 0) +{ +lean_dec(x_85); +lean_dec(x_84); +lean_ctor_set(x_6, 1, x_2); +return x_5; +} +else +{ +size_t x_89; size_t x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; +lean_free_object(x_6); +lean_free_object(x_5); +x_89 = 0; +x_90 = lean_usize_of_nat(x_85); +lean_dec(x_85); +x_91 = lean_box(0); +x_92 = l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(x_84, x_89, x_90, x_91, x_2, x_79); +lean_dec(x_84); +x_93 = !lean_is_exclusive(x_92); +if (x_93 == 0) +{ +lean_object* x_94; uint8_t x_95; +x_94 = lean_ctor_get(x_92, 0); +x_95 = !lean_is_exclusive(x_94); +if (x_95 == 0) +{ +lean_object* x_96; +x_96 = lean_ctor_get(x_94, 0); +lean_dec(x_96); +lean_ctor_set_tag(x_94, 1); +lean_ctor_set(x_94, 0, x_82); +return x_92; +} +else +{ +lean_object* x_97; lean_object* x_98; +x_97 = lean_ctor_get(x_94, 1); +lean_inc(x_97); +lean_dec(x_94); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_82); +lean_ctor_set(x_98, 1, x_97); +lean_ctor_set(x_92, 0, x_98); +return x_92; +} +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_99 = lean_ctor_get(x_92, 0); +x_100 = lean_ctor_get(x_92, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_92); +x_101 = lean_ctor_get(x_99, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_99)) { + lean_ctor_release(x_99, 0); + lean_ctor_release(x_99, 1); + x_102 = x_99; +} else { + lean_dec_ref(x_99); + x_102 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_103 = lean_alloc_ctor(1, 2, 0); +} else { + x_103 = x_102; + lean_ctor_set_tag(x_103, 1); +} +lean_ctor_set(x_103, 0, x_82); +lean_ctor_set(x_103, 1, x_101); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_100); +return x_104; +} +} +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; uint8_t x_109; +x_105 = lean_ctor_get(x_6, 0); +lean_inc(x_105); +lean_dec(x_6); +x_106 = lean_ctor_get(x_77, 0); +lean_inc(x_106); +lean_dec(x_77); +x_107 = lean_array_get_size(x_106); +x_108 = lean_unsigned_to_nat(0u); +x_109 = lean_nat_dec_lt(x_108, x_107); +if (x_109 == 0) +{ +lean_object* x_110; +lean_dec(x_107); +lean_dec(x_106); +x_110 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_110, 0, x_105); +lean_ctor_set(x_110, 1, x_2); +lean_ctor_set(x_5, 0, x_110); +return x_5; +} +else +{ +uint8_t x_111; +x_111 = lean_nat_dec_le(x_107, x_107); +if (x_111 == 0) +{ +lean_object* x_112; +lean_dec(x_107); +lean_dec(x_106); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_105); +lean_ctor_set(x_112, 1, x_2); +lean_ctor_set(x_5, 0, x_112); +return x_5; +} +else +{ +size_t x_113; size_t x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +lean_free_object(x_5); +x_113 = 0; +x_114 = lean_usize_of_nat(x_107); +lean_dec(x_107); +x_115 = lean_box(0); +x_116 = l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(x_106, x_113, x_114, x_115, x_2, x_79); +lean_dec(x_106); +x_117 = lean_ctor_get(x_116, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_116, 1); +lean_inc(x_118); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + lean_ctor_release(x_116, 1); + x_119 = x_116; +} else { + lean_dec_ref(x_116); + x_119 = lean_box(0); +} +x_120 = lean_ctor_get(x_117, 1); +lean_inc(x_120); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_121 = x_117; +} else { + lean_dec_ref(x_117); + x_121 = lean_box(0); +} +if (lean_is_scalar(x_121)) { + x_122 = lean_alloc_ctor(1, 2, 0); +} else { + x_122 = x_121; + lean_ctor_set_tag(x_122, 1); +} +lean_ctor_set(x_122, 0, x_105); +lean_ctor_set(x_122, 1, x_120); +if (lean_is_scalar(x_119)) { + x_123 = lean_alloc_ctor(0, 2, 0); +} else { + x_123 = x_119; +} +lean_ctor_set(x_123, 0, x_122); +lean_ctor_set(x_123, 1, x_118); +return x_123; +} +} +} +} +else +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; +x_124 = lean_ctor_get(x_5, 1); +lean_inc(x_124); +lean_dec(x_5); +x_125 = lean_ctor_get(x_6, 0); +lean_inc(x_125); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + lean_ctor_release(x_6, 1); + x_126 = x_6; +} else { + lean_dec_ref(x_6); + x_126 = lean_box(0); +} +x_127 = lean_ctor_get(x_77, 0); +lean_inc(x_127); +lean_dec(x_77); +x_128 = lean_array_get_size(x_127); +x_129 = lean_unsigned_to_nat(0u); +x_130 = lean_nat_dec_lt(x_129, x_128); +if (x_130 == 0) +{ +lean_object* x_131; lean_object* x_132; +lean_dec(x_128); +lean_dec(x_127); +if (lean_is_scalar(x_126)) { + x_131 = lean_alloc_ctor(1, 2, 0); +} else { + x_131 = x_126; +} +lean_ctor_set(x_131, 0, x_125); +lean_ctor_set(x_131, 1, x_2); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_124); +return x_132; +} +else +{ +uint8_t x_133; +x_133 = lean_nat_dec_le(x_128, x_128); +if (x_133 == 0) +{ +lean_object* x_134; lean_object* x_135; +lean_dec(x_128); +lean_dec(x_127); +if (lean_is_scalar(x_126)) { + x_134 = lean_alloc_ctor(1, 2, 0); +} else { + x_134 = x_126; +} +lean_ctor_set(x_134, 0, x_125); +lean_ctor_set(x_134, 1, x_2); +x_135 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_124); +return x_135; +} +else +{ +size_t x_136; size_t x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; +lean_dec(x_126); +x_136 = 0; +x_137 = lean_usize_of_nat(x_128); +lean_dec(x_128); +x_138 = lean_box(0); +x_139 = l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(x_127, x_136, x_137, x_138, x_2, x_124); +lean_dec(x_127); +x_140 = lean_ctor_get(x_139, 0); +lean_inc(x_140); +x_141 = lean_ctor_get(x_139, 1); +lean_inc(x_141); +if (lean_is_exclusive(x_139)) { + lean_ctor_release(x_139, 0); + lean_ctor_release(x_139, 1); + x_142 = x_139; +} else { + lean_dec_ref(x_139); + x_142 = lean_box(0); +} +x_143 = lean_ctor_get(x_140, 1); +lean_inc(x_143); +if (lean_is_exclusive(x_140)) { + lean_ctor_release(x_140, 0); + lean_ctor_release(x_140, 1); + x_144 = x_140; +} else { + lean_dec_ref(x_140); + x_144 = lean_box(0); +} +if (lean_is_scalar(x_144)) { + x_145 = lean_alloc_ctor(1, 2, 0); +} else { + x_145 = x_144; + lean_ctor_set_tag(x_145, 1); +} +lean_ctor_set(x_145, 0, x_125); +lean_ctor_set(x_145, 1, x_143); +if (lean_is_scalar(x_142)) { + x_146 = lean_alloc_ctor(0, 2, 0); +} else { + x_146 = x_142; +} +lean_ctor_set(x_146, 0, x_145); +lean_ctor_set(x_146, 1, x_141); +return x_146; +} +} +} +} +} +else +{ +uint8_t x_147; +lean_dec(x_2); +x_147 = !lean_is_exclusive(x_5); +if (x_147 == 0) +{ +return x_5; +} +else +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_5, 0); +x_149 = lean_ctor_get(x_5, 1); +lean_inc(x_149); +lean_inc(x_148); +lean_dec(x_5); +x_150 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_150, 0, x_148); +lean_ctor_set(x_150, 1, x_149); +return x_150; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_await(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Job_await___rarg), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +size_t x_7; size_t x_8; lean_object* x_9; +x_7 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_8 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_9 = l_Array_foldlMUnsafe_fold___at_Lake_Job_await___spec__1(x_1, x_7, x_8, x_4, x_5, x_6); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_bindSync___spec__2___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Job_bindSync___spec__3___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_bindSync___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Job_bindSync___spec__4(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Job_bindSync___spec__4___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__5___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Job_bindSync___spec__5(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_bindSync___spec__5___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Job_bindSync___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Job_bindSync___spec__6___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_bindSync___spec__2___rarg), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_Job_bindSync___spec__3___rarg(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Job_bindSync___spec__4___rarg), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_bindSync___spec__5___rarg), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_Job_bindSync___spec__6___rarg(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_bindSync___spec__2___rarg), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_Job_bindSync___spec__3___rarg(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Job_bindSync___spec__4___rarg), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Job_bindSync___spec__5___rarg), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_Job_bindSync___spec__6___rarg(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindSync___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_3, 1); +lean_inc(x_6); +lean_dec(x_3); +x_7 = lean_apply_1(x_1, x_5); +x_8 = 1; +lean_inc(x_2); +x_9 = l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1___rarg(x_7, x_8, x_2, x_6, x_4); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = l_String_isEmpty(x_14); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; uint8_t x_23; +x_17 = l_Lake_Job_async___rarg___lambda__2___closed__1; +x_18 = lean_string_append(x_17, x_14); +lean_dec(x_14); +x_19 = l_Lake_instInhabitedJob___closed__3; +x_20 = lean_string_append(x_18, x_19); +x_21 = 1; +x_22 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set_uint8(x_22, sizeof(void*)*1, x_21); +x_23 = !lean_is_exclusive(x_13); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_24 = lean_ctor_get(x_13, 0); +x_25 = lean_array_push(x_24, x_22); +lean_ctor_set(x_13, 0, x_25); +x_26 = lean_box(0); +x_27 = l_Lake_Job_async___rarg___lambda__1(x_15, x_26, x_2, x_13, x_12); +lean_dec(x_2); +return x_27; +} +else +{ +lean_object* x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_13, 0); +x_29 = lean_ctor_get_uint8(x_13, sizeof(void*)*1); +lean_inc(x_28); +lean_dec(x_13); +x_30 = lean_array_push(x_28, x_22); +x_31 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set_uint8(x_31, sizeof(void*)*1, x_29); +x_32 = lean_box(0); +x_33 = l_Lake_Job_async___rarg___lambda__1(x_15, x_32, x_2, x_31, x_12); +lean_dec(x_2); +return x_33; +} +} +else +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_14); +x_34 = lean_box(0); +x_35 = l_Lake_Job_async___rarg___lambda__1(x_15, x_34, x_2, x_13, x_12); +lean_dec(x_2); +return x_35; +} +} +else +{ +uint8_t x_36; +lean_dec(x_2); +x_36 = !lean_is_exclusive(x_9); +if (x_36 == 0) +{ +lean_object* x_37; uint8_t x_38; +x_37 = lean_ctor_get(x_9, 0); +lean_dec(x_37); +x_38 = !lean_is_exclusive(x_10); +if (x_38 == 0) +{ +return x_9; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_39 = lean_ctor_get(x_10, 0); +x_40 = lean_ctor_get(x_10, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_10); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_40); +lean_ctor_set(x_9, 0, x_41); +return x_9; +} +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_42 = lean_ctor_get(x_9, 1); +lean_inc(x_42); +lean_dec(x_9); +x_43 = lean_ctor_get(x_10, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_10, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_45 = x_10; +} else { + lean_dec_ref(x_10); + x_45 = lean_box(0); +} +if (lean_is_scalar(x_45)) { + x_46 = lean_alloc_ctor(1, 2, 0); +} else { + x_46 = x_45; +} +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_44); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_42); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_dec(x_2); +x_48 = !lean_is_exclusive(x_9); +if (x_48 == 0) +{ +return x_9; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_9, 0); +x_50 = lean_ctor_get(x_9, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_9); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +uint8_t x_52; +lean_dec(x_2); +lean_dec(x_1); +x_52 = !lean_is_exclusive(x_3); +if (x_52 == 0) +{ +lean_object* x_53; +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_3); +lean_ctor_set(x_53, 1, x_4); +return x_53; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_54 = lean_ctor_get(x_3, 0); +x_55 = lean_ctor_get(x_3, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_3); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_4); +return x_57; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindSync___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_1); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +x_10 = lean_alloc_closure((void*)(l_Lake_Job_bindSync___rarg___lambda__1), 4, 2); +lean_closure_set(x_10, 0, x_2); +lean_closure_set(x_10, 1, x_5); +x_11 = lean_io_map_task(x_10, x_8, x_3, x_4, x_6); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_ctor_set(x_1, 0, x_13); +lean_ctor_set(x_11, 0, x_1); +return x_11; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_11, 0); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_11); +lean_ctor_set(x_1, 0, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_free_object(x_1); +lean_dec(x_9); +x_17 = !lean_is_exclusive(x_11); +if (x_17 == 0) +{ +return x_11; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_11, 0); +x_19 = lean_ctor_get(x_11, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_11); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_1, 0); +x_22 = lean_ctor_get(x_1, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_1); +x_23 = lean_alloc_closure((void*)(l_Lake_Job_bindSync___rarg___lambda__1), 4, 2); +lean_closure_set(x_23, 0, x_2); +lean_closure_set(x_23, 1, x_5); +x_24 = lean_io_map_task(x_23, x_21, x_3, x_4, x_6); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_24, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_27 = x_24; +} else { + lean_dec_ref(x_24); + x_27 = lean_box(0); +} +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_25); +lean_ctor_set(x_28, 1, x_22); +if (lean_is_scalar(x_27)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_27; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +return x_29; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_22); +x_30 = lean_ctor_get(x_24, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_24, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_32 = x_24; +} else { + lean_dec_ref(x_24); + x_32 = lean_box(0); +} +if (lean_is_scalar(x_32)) { + x_33 = lean_alloc_ctor(1, 2, 0); +} else { + x_33 = x_32; +} +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_31); +return x_33; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindSync(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_Job_bindSync___rarg___boxed), 6, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Job_bindSync___spec__1___rarg(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindSync___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_4); +lean_dec(x_4); +x_8 = l_Lake_Job_bindSync___rarg(x_1, x_2, x_3, x_7, x_5, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 1); +x_5 = l_Lake_JobState_merge(x_1, x_4); +lean_ctor_set(x_2, 1, x_5); +return x_2; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +lean_inc(x_7); +lean_inc(x_6); +lean_dec(x_2); +x_8 = l_Lake_JobState_merge(x_1, x_7); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_6); +lean_ctor_set(x_9, 1, x_8); +return x_9; +} +} +else +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_2); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get(x_2, 1); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = lean_array_get_size(x_13); +lean_dec(x_13); +x_15 = lean_nat_add(x_14, x_11); +lean_dec(x_11); +lean_dec(x_14); +x_16 = l_Lake_JobState_merge(x_1, x_12); +lean_ctor_set(x_2, 1, x_16); +lean_ctor_set(x_2, 0, x_15); +return x_2; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_2, 0); +x_18 = lean_ctor_get(x_2, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_2); +x_19 = lean_ctor_get(x_1, 0); +lean_inc(x_19); +x_20 = lean_array_get_size(x_19); +lean_dec(x_19); +x_21 = lean_nat_add(x_20, x_17); +lean_dec(x_17); +lean_dec(x_20); +x_22 = l_Lake_JobState_merge(x_1, x_18); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); +lean_dec(x_4); +x_8 = lean_apply_3(x_1, x_6, x_2, x_5); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_10 = lean_ctor_get(x_8, 0); +x_11 = lean_alloc_closure((void*)(l_Lake_Job_bindAsync___rarg___lambda__1), 2, 1); +lean_closure_set(x_11, 0, x_7); +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +lean_dec(x_10); +x_13 = 1; +x_14 = lean_task_map(x_11, x_12, x_3, x_13); +lean_ctor_set(x_8, 0, x_14); +return x_8; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; +x_15 = lean_ctor_get(x_8, 0); +x_16 = lean_ctor_get(x_8, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_8); +x_17 = lean_alloc_closure((void*)(l_Lake_Job_bindAsync___rarg___lambda__1), 2, 1); +lean_closure_set(x_17, 0, x_7); +x_18 = lean_ctor_get(x_15, 0); +lean_inc(x_18); +lean_dec(x_15); +x_19 = 1; +x_20 = lean_task_map(x_17, x_18, x_3, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_16); +return x_21; +} +} +else +{ +uint8_t x_22; +lean_dec(x_7); +lean_dec(x_3); +x_22 = !lean_is_exclusive(x_8); +if (x_22 == 0) +{ +return x_8; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_8, 0); +x_24 = lean_ctor_get(x_8, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_8); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +return x_25; +} +} +} +else +{ +uint8_t x_26; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_26 = !lean_is_exclusive(x_4); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_task_pure(x_4); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_5); +return x_28; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_ctor_get(x_4, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_4); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +x_32 = lean_task_pure(x_31); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_5); +return x_33; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_1); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_3); +x_10 = lean_alloc_closure((void*)(l_Lake_Job_bindAsync___rarg___lambda__2), 5, 3); +lean_closure_set(x_10, 0, x_2); +lean_closure_set(x_10, 1, x_5); +lean_closure_set(x_10, 2, x_3); +x_11 = lean_io_bind_task(x_8, x_10, x_3, x_4, x_6); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_ctor_set(x_1, 0, x_13); +lean_ctor_set(x_11, 0, x_1); +return x_11; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_11, 0); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_11); +lean_ctor_set(x_1, 0, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_free_object(x_1); +lean_dec(x_9); +x_17 = !lean_is_exclusive(x_11); +if (x_17 == 0) +{ +return x_11; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_11, 0); +x_19 = lean_ctor_get(x_11, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_11); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_1, 0); +x_22 = lean_ctor_get(x_1, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_1); +lean_inc(x_3); +x_23 = lean_alloc_closure((void*)(l_Lake_Job_bindAsync___rarg___lambda__2), 5, 3); +lean_closure_set(x_23, 0, x_2); +lean_closure_set(x_23, 1, x_5); +lean_closure_set(x_23, 2, x_3); +x_24 = lean_io_bind_task(x_21, x_23, x_3, x_4, x_6); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_24, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_27 = x_24; +} else { + lean_dec_ref(x_24); + x_27 = lean_box(0); +} +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_25); +lean_ctor_set(x_28, 1, x_22); +if (lean_is_scalar(x_27)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_27; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +return x_29; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_22); +x_30 = lean_ctor_get(x_24, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_24, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_32 = x_24; +} else { + lean_dec_ref(x_24); + x_32 = lean_box(0); +} +if (lean_is_scalar(x_32)) { + x_33 = lean_alloc_ctor(1, 2, 0); +} else { + x_33 = x_32; +} +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_31); +return x_33; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_Job_bindAsync___rarg___boxed), 6, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_bindAsync___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_4); +lean_dec(x_4); +x_8 = l_Lake_Job_bindAsync___rarg(x_1, x_2, x_3, x_7, x_5, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = !lean_is_exclusive(x_3); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_7 = lean_ctor_get(x_3, 0); +x_8 = lean_ctor_get(x_3, 1); +x_9 = lean_apply_2(x_2, x_4, x_7); +x_10 = l_Lake_JobState_merge(x_5, x_8); +lean_ctor_set(x_3, 1, x_10); +lean_ctor_set(x_3, 0, x_9); +return x_3; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_11 = lean_ctor_get(x_3, 0); +x_12 = lean_ctor_get(x_3, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_3); +x_13 = lean_apply_2(x_2, x_4, x_11); +x_14 = l_Lake_JobState_merge(x_5, x_12); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +return x_15; +} +} +else +{ +lean_object* x_16; uint8_t x_17; +lean_dec(x_2); +x_16 = lean_ctor_get(x_1, 1); +lean_inc(x_16); +lean_dec(x_1); +x_17 = !lean_is_exclusive(x_3); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_3, 1); +x_19 = lean_ctor_get(x_3, 0); +lean_dec(x_19); +x_20 = l_Lake_JobState_merge(x_16, x_18); +x_21 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_3, 1, x_20); +lean_ctor_set(x_3, 0, x_21); +return x_3; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_3, 1); +lean_inc(x_22); +lean_dec(x_3); +x_23 = l_Lake_JobState_merge(x_16, x_22); +x_24 = lean_unsigned_to_nat(0u); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_23); +return x_25; +} +} +} +else +{ +lean_dec(x_2); +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_26; uint8_t x_27; +x_26 = lean_ctor_get(x_1, 1); +lean_inc(x_26); +lean_dec(x_1); +x_27 = !lean_is_exclusive(x_3); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_28 = lean_ctor_get(x_3, 1); +x_29 = lean_ctor_get(x_3, 0); +lean_dec(x_29); +x_30 = l_Lake_JobState_merge(x_26, x_28); +x_31 = lean_unsigned_to_nat(0u); +lean_ctor_set_tag(x_3, 1); +lean_ctor_set(x_3, 1, x_30); +lean_ctor_set(x_3, 0, x_31); +return x_3; +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_32 = lean_ctor_get(x_3, 1); +lean_inc(x_32); +lean_dec(x_3); +x_33 = l_Lake_JobState_merge(x_26, x_32); +x_34 = lean_unsigned_to_nat(0u); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_33); +return x_35; +} +} +else +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_1, 1); +lean_inc(x_36); +lean_dec(x_1); +x_37 = !lean_is_exclusive(x_3); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_3, 1); +x_39 = lean_ctor_get(x_3, 0); +lean_dec(x_39); +x_40 = l_Lake_JobState_merge(x_36, x_38); +x_41 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_3, 1, x_40); +lean_ctor_set(x_3, 0, x_41); +return x_3; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_42 = lean_ctor_get(x_3, 1); +lean_inc(x_42); +lean_dec(x_3); +x_43 = l_Lake_JobState_merge(x_36, x_42); +x_44 = lean_unsigned_to_nat(0u); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_43); +return x_45; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_alloc_closure((void*)(l_Lake_Job_zipWith___rarg___lambda__1), 3, 2); +lean_closure_set(x_6, 0, x_5); +lean_closure_set(x_6, 1, x_1); +x_7 = lean_ctor_get(x_2, 0); +lean_inc(x_7); +lean_dec(x_2); +x_8 = lean_task_map(x_6, x_7, x_3, x_4); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_6 = lean_ctor_get(x_2, 0); +lean_inc(x_6); +lean_dec(x_2); +x_7 = lean_box(x_5); +lean_inc(x_4); +x_8 = lean_alloc_closure((void*)(l_Lake_Job_zipWith___rarg___lambda__2___boxed), 5, 4); +lean_closure_set(x_8, 0, x_1); +lean_closure_set(x_8, 1, x_3); +lean_closure_set(x_8, 2, x_4); +lean_closure_set(x_8, 3, x_7); +x_9 = 1; +x_10 = lean_task_bind(x_6, x_8, x_4, x_9); +x_11 = l_Lake_instInhabitedJob___closed__3; +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set(x_12, 1, x_11); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_zipWith(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_Job_zipWith___rarg___boxed), 5, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_4); +lean_dec(x_4); +x_7 = l_Lake_Job_zipWith___rarg___lambda__2(x_1, x_2, x_3, x_6, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Job_zipWith___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_5); +lean_dec(x_5); +x_7 = l_Lake_Job_zipWith___rarg(x_1, x_2, x_3, x_4, x_6); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mk___rarg(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mk(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_mk___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mk___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_BuildJob_mk___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_ofJob___lambda__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = lean_box(0); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_ofJob___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildJob_ofJob___lambda__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildJob_ofJob___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_BuildJob_ofJob___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_ofJob(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Lake_BuildJob_ofJob___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Lake_BuildJob_ofJob___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_toJob___rarg(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_toJob(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_toJob___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_toJob___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_BuildJob_toJob___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_nil___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_nil___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_nil___closed__1; +x_2 = l_Lake_instInhabitedJobState___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_nil___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_BuildJob_nil___closed__2; +x_2 = lean_task_pure(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_nil___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_nil___closed__3; +x_2 = l_Lake_instInhabitedJob___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_nil() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildJob_nil___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_pure___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +x_4 = l_Lake_instInhabitedJobState___closed__1; +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_3); +lean_ctor_set(x_5, 1, x_4); +x_6 = lean_task_pure(x_5); +x_7 = l_Lake_instInhabitedJob___closed__3; +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_6); +lean_ctor_set(x_8, 1, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_pure(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_pure___rarg), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_instPure___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +x_4 = l_Lake_instInhabitedJobState___closed__1; +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_3); +lean_ctor_set(x_5, 1, x_4); +x_6 = lean_task_pure(x_5); +x_7 = l_Lake_instInhabitedJob___closed__3; +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_6); +lean_ctor_set(x_8, 1, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_instPure(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_instPure___rarg), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_map___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_apply_1(x_1, x_4); +lean_ctor_set(x_2, 0, x_5); +return x_2; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +lean_inc(x_7); +lean_inc(x_6); +lean_dec(x_2); +x_8 = lean_apply_1(x_1, x_6); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_7); +return x_9; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_map___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_map___rarg___lambda__1), 2, 1); +lean_closure_set(x_3, 0, x_1); +x_4 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_4, 0, x_3); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = l_Task_Priority_default; +x_8 = 0; +x_9 = lean_task_map(x_4, x_6, x_7, x_8); +lean_ctor_set(x_2, 0, x_9); +return x_2; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; +x_10 = lean_ctor_get(x_2, 0); +x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_2); +x_12 = l_Task_Priority_default; +x_13 = 0; +x_14 = lean_task_map(x_4, x_10, x_12, x_13); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_11); +return x_15; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_map(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_map___rarg), 2, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_instFunctor___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_5 = lean_alloc_closure((void*)(l_Lake_BuildJob_map___rarg___lambda__1), 2, 1); +lean_closure_set(x_5, 0, x_3); +x_6 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_6, 0, x_5); +x_7 = !lean_is_exclusive(x_4); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_4, 0); +x_9 = l_Task_Priority_default; +x_10 = 0; +x_11 = lean_task_map(x_6, x_8, x_9, x_10); +lean_ctor_set(x_4, 0, x_11); +return x_4; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; +x_12 = lean_ctor_get(x_4, 0); +x_13 = lean_ctor_get(x_4, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_4); +x_14 = l_Task_Priority_default; +x_15 = 0; +x_16 = lean_task_map(x_6, x_12, x_14, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_13); +return x_17; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_instFunctor___lambda__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; +x_4 = lean_ctor_get(x_2, 0); +lean_dec(x_4); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +else +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +lean_dec(x_2); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_5); +return x_6; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_instFunctor___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_5 = lean_alloc_closure((void*)(l_Lake_BuildJob_instFunctor___lambda__2), 2, 1); +lean_closure_set(x_5, 0, x_3); +x_6 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_6, 0, x_5); +x_7 = !lean_is_exclusive(x_4); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_4, 0); +x_9 = l_Task_Priority_default; +x_10 = 0; +x_11 = lean_task_map(x_6, x_8, x_9, x_10); +lean_ctor_set(x_4, 0, x_11); +return x_4; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; +x_12 = lean_ctor_get(x_4, 0); +x_13 = lean_ctor_get(x_4, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_4); +x_14 = l_Task_Priority_default; +x_15 = 0; +x_16 = lean_task_map(x_6, x_12, x_14, x_15); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_13); +return x_17; +} +} +} +static lean_object* _init_l_Lake_BuildJob_instFunctor___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildJob_instFunctor___lambda__1), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildJob_instFunctor___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildJob_instFunctor___lambda__3), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildJob_instFunctor___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_instFunctor___closed__1; +x_2 = l_Lake_BuildJob_instFunctor___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_instFunctor() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildJob_instFunctor___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mapWithTrace___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_3 = lean_ctor_get(x_2, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_2, 1); +lean_inc(x_4); +lean_dec(x_2); +x_5 = lean_apply_2(x_1, x_3, x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mapWithTrace___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_mapWithTrace___rarg___lambda__1), 2, 1); +lean_closure_set(x_3, 0, x_1); +x_4 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_4, 0, x_3); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = l_Task_Priority_default; +x_8 = 0; +x_9 = lean_task_map(x_4, x_6, x_7, x_8); +lean_ctor_set(x_2, 0, x_9); +return x_2; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; +x_10 = lean_ctor_get(x_2, 0); +x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_2); +x_12 = l_Task_Priority_default; +x_13 = 0; +x_14 = lean_task_map(x_4, x_10, x_12, x_13); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_11); +return x_15; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mapWithTrace(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_mapWithTrace___rarg), 2, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__2___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__3___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_BuildJob_bindSync___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_BuildJob_bindSync___spec__4(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_BuildJob_bindSync___spec__4___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__5___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__5(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__5___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__6___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__2___rarg), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__3___rarg(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_BuildJob_bindSync___spec__4___rarg), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__5___rarg), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__6___rarg(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__2___rarg), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__3___rarg(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_BuildJob_bindSync___spec__4___rarg), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_BuildJob_bindSync___spec__5___rarg), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_BuildJob_bindSync___spec__6___rarg(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_3, 1); +lean_inc(x_6); +lean_dec(x_3); +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = lean_apply_2(x_1, x_7, x_8); +x_10 = 1; +lean_inc(x_2); +x_11 = l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1___rarg(x_9, x_10, x_2, x_6, x_4); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +lean_dec(x_11); +x_15 = lean_ctor_get(x_12, 1); +lean_inc(x_15); +lean_dec(x_12); +x_16 = lean_ctor_get(x_13, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_13, 1); +lean_inc(x_17); +lean_dec(x_13); +x_18 = l_String_isEmpty(x_16); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; uint8_t x_25; +x_19 = l_Lake_Job_async___rarg___lambda__2___closed__1; +x_20 = lean_string_append(x_19, x_16); +lean_dec(x_16); +x_21 = l_Lake_instInhabitedJob___closed__3; +x_22 = lean_string_append(x_20, x_21); +x_23 = 1; +x_24 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set_uint8(x_24, sizeof(void*)*1, x_23); +x_25 = !lean_is_exclusive(x_15); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_26 = lean_ctor_get(x_15, 0); +x_27 = lean_array_push(x_26, x_24); +lean_ctor_set(x_15, 0, x_27); +x_28 = lean_box(0); +x_29 = l_Lake_Job_async___rarg___lambda__1(x_17, x_28, x_2, x_15, x_14); +lean_dec(x_2); +return x_29; +} +else +{ +lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_30 = lean_ctor_get(x_15, 0); +x_31 = lean_ctor_get_uint8(x_15, sizeof(void*)*1); +lean_inc(x_30); +lean_dec(x_15); +x_32 = lean_array_push(x_30, x_24); +x_33 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set_uint8(x_33, sizeof(void*)*1, x_31); +x_34 = lean_box(0); +x_35 = l_Lake_Job_async___rarg___lambda__1(x_17, x_34, x_2, x_33, x_14); +lean_dec(x_2); +return x_35; +} +} +else +{ +lean_object* x_36; lean_object* x_37; +lean_dec(x_16); +x_36 = lean_box(0); +x_37 = l_Lake_Job_async___rarg___lambda__1(x_17, x_36, x_2, x_15, x_14); +lean_dec(x_2); +return x_37; +} +} +else +{ +uint8_t x_38; +lean_dec(x_2); +x_38 = !lean_is_exclusive(x_11); +if (x_38 == 0) +{ +lean_object* x_39; uint8_t x_40; +x_39 = lean_ctor_get(x_11, 0); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_12); +if (x_40 == 0) +{ +return x_11; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_12, 0); +x_42 = lean_ctor_get(x_12, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_12); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +lean_ctor_set(x_11, 0, x_43); +return x_11; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_44 = lean_ctor_get(x_11, 1); +lean_inc(x_44); +lean_dec(x_11); +x_45 = lean_ctor_get(x_12, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_12, 1); +lean_inc(x_46); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_47 = x_12; +} else { + lean_dec_ref(x_12); + x_47 = lean_box(0); +} +if (lean_is_scalar(x_47)) { + x_48 = lean_alloc_ctor(1, 2, 0); +} else { + x_48 = x_47; +} +lean_ctor_set(x_48, 0, x_45); +lean_ctor_set(x_48, 1, x_46); +x_49 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_44); +return x_49; +} +} +} +else +{ +uint8_t x_50; +lean_dec(x_2); +x_50 = !lean_is_exclusive(x_11); +if (x_50 == 0) +{ +return x_11; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_11, 0); +x_52 = lean_ctor_get(x_11, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_11); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; +} +} +} +else +{ +uint8_t x_54; +lean_dec(x_2); +lean_dec(x_1); +x_54 = !lean_is_exclusive(x_3); +if (x_54 == 0) +{ +lean_object* x_55; +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_3); +lean_ctor_set(x_55, 1, x_4); +return x_55; +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_3, 0); +x_57 = lean_ctor_get(x_3, 1); +lean_inc(x_57); +lean_inc(x_56); +lean_dec(x_3); +x_58 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_58, 0, x_56); +lean_ctor_set(x_58, 1, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_4); +return x_59; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_1); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +x_10 = lean_alloc_closure((void*)(l_Lake_BuildJob_bindSync___rarg___lambda__1), 4, 2); +lean_closure_set(x_10, 0, x_2); +lean_closure_set(x_10, 1, x_5); +x_11 = lean_io_map_task(x_10, x_8, x_3, x_4, x_6); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_ctor_set(x_1, 0, x_13); +lean_ctor_set(x_11, 0, x_1); +return x_11; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_11, 0); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_11); +lean_ctor_set(x_1, 0, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_free_object(x_1); +lean_dec(x_9); +x_17 = !lean_is_exclusive(x_11); +if (x_17 == 0) +{ +return x_11; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_11, 0); +x_19 = lean_ctor_get(x_11, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_11); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_1, 0); +x_22 = lean_ctor_get(x_1, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_1); +x_23 = lean_alloc_closure((void*)(l_Lake_BuildJob_bindSync___rarg___lambda__1), 4, 2); +lean_closure_set(x_23, 0, x_2); +lean_closure_set(x_23, 1, x_5); +x_24 = lean_io_map_task(x_23, x_21, x_3, x_4, x_6); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_24, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_27 = x_24; +} else { + lean_dec_ref(x_24); + x_27 = lean_box(0); +} +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_25); +lean_ctor_set(x_28, 1, x_22); +if (lean_is_scalar(x_27)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_27; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +return x_29; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_22); +x_30 = lean_ctor_get(x_24, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_24, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_32 = x_24; +} else { + lean_dec_ref(x_24); + x_32 = lean_box(0); +} +if (lean_is_scalar(x_32)) { + x_33 = lean_alloc_ctor(1, 2, 0); +} else { + x_33 = x_32; +} +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_31); +return x_33; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_bindSync___rarg___boxed), 6, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_BuildJob_bindSync___spec__1___rarg(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindSync___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_4); +lean_dec(x_4); +x_8 = l_Lake_BuildJob_bindSync___rarg(x_1, x_2, x_3, x_7, x_5, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); +lean_dec(x_4); +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_apply_4(x_1, x_8, x_9, x_2, x_5); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_10, 0); +x_13 = lean_alloc_closure((void*)(l_Lake_Job_bindAsync___rarg___lambda__1), 2, 1); +lean_closure_set(x_13, 0, x_7); +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +lean_dec(x_12); +x_15 = 1; +x_16 = lean_task_map(x_13, x_14, x_3, x_15); +lean_ctor_set(x_10, 0, x_16); +return x_10; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_10, 0); +x_18 = lean_ctor_get(x_10, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_10); +x_19 = lean_alloc_closure((void*)(l_Lake_Job_bindAsync___rarg___lambda__1), 2, 1); +lean_closure_set(x_19, 0, x_7); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +lean_dec(x_17); +x_21 = 1; +x_22 = lean_task_map(x_19, x_20, x_3, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_18); +return x_23; +} +} +else +{ +uint8_t x_24; +lean_dec(x_7); +lean_dec(x_3); +x_24 = !lean_is_exclusive(x_10); +if (x_24 == 0) +{ +return x_10; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_10, 0); +x_26 = lean_ctor_get(x_10, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_10); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +} +else +{ +uint8_t x_28; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_task_pure(x_4); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_5); +return x_30; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_31 = lean_ctor_get(x_4, 0); +x_32 = lean_ctor_get(x_4, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_4); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +x_34 = lean_task_pure(x_33); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_5); +return x_35; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_1); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_3); +x_10 = lean_alloc_closure((void*)(l_Lake_BuildJob_bindAsync___rarg___lambda__1), 5, 3); +lean_closure_set(x_10, 0, x_2); +lean_closure_set(x_10, 1, x_5); +lean_closure_set(x_10, 2, x_3); +x_11 = lean_io_bind_task(x_8, x_10, x_3, x_4, x_6); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_ctor_set(x_1, 0, x_13); +lean_ctor_set(x_11, 0, x_1); +return x_11; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_11, 0); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_11); +lean_ctor_set(x_1, 0, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_free_object(x_1); +lean_dec(x_9); +x_17 = !lean_is_exclusive(x_11); +if (x_17 == 0) +{ +return x_11; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_11, 0); +x_19 = lean_ctor_get(x_11, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_11); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +return x_20; +} +} +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_1, 0); +x_22 = lean_ctor_get(x_1, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_1); +lean_inc(x_3); +x_23 = lean_alloc_closure((void*)(l_Lake_BuildJob_bindAsync___rarg___lambda__1), 5, 3); +lean_closure_set(x_23, 0, x_2); +lean_closure_set(x_23, 1, x_5); +lean_closure_set(x_23, 2, x_3); +x_24 = lean_io_bind_task(x_21, x_23, x_3, x_4, x_6); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_24, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_27 = x_24; +} else { + lean_dec_ref(x_24); + x_27 = lean_box(0); +} +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_25); +lean_ctor_set(x_28, 1, x_22); +if (lean_is_scalar(x_27)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_27; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +return x_29; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_22); +x_30 = lean_ctor_get(x_24, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_24, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_32 = x_24; +} else { + lean_dec_ref(x_24); + x_32 = lean_box(0); +} +if (lean_is_scalar(x_32)) { + x_33 = lean_alloc_ctor(1, 2, 0); +} else { + x_33 = x_32; +} +lean_ctor_set(x_33, 0, x_30); +lean_ctor_set(x_33, 1, x_31); +return x_33; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_bindAsync___rarg___boxed), 6, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_bindAsync___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_4); +lean_dec(x_4); +x_8 = l_Lake_BuildJob_bindAsync___rarg(x_1, x_2, x_3, x_7, x_5, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_wait_x3f___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = lean_io_wait(x_3, x_2); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +lean_dec(x_5); +x_7 = !lean_is_exclusive(x_4); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_4, 0); +lean_dec(x_8); +x_9 = lean_ctor_get(x_6, 0); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_4, 0, x_10); +return x_4; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_4, 1); +lean_inc(x_11); +lean_dec(x_4); +x_12 = lean_ctor_get(x_6, 0); +lean_inc(x_12); +lean_dec(x_6); +x_13 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_13, 0, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_11); +return x_14; +} +} +else +{ +uint8_t x_15; +lean_dec(x_5); +x_15 = !lean_is_exclusive(x_4); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_4, 0); +lean_dec(x_16); +x_17 = lean_box(0); +lean_ctor_set(x_4, 0, x_17); +return x_4; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_4, 1); +lean_inc(x_18); +lean_dec(x_4); +x_19 = lean_box(0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_18); +return x_20; +} +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_4); +if (x_21 == 0) +{ +return x_4; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_4, 0); +x_23 = lean_ctor_get(x_4, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_4); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +return x_24; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_wait_x3f(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_wait_x3f___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_add___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +lean_dec(x_1); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_ctor_get(x_2, 1); +x_7 = lean_ctor_get(x_2, 0); +lean_dec(x_7); +x_8 = l_Lake_JobState_merge(x_4, x_6); +lean_ctor_set(x_2, 1, x_8); +lean_ctor_set(x_2, 0, x_3); +return x_2; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_2, 1); +lean_inc(x_9); +lean_dec(x_2); +x_10 = l_Lake_JobState_merge(x_4, x_9); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_3); +lean_ctor_set(x_11, 1, x_10); +return x_11; +} +} +else +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_1, 1); +lean_inc(x_12); +lean_dec(x_1); +x_13 = !lean_is_exclusive(x_2); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = lean_ctor_get(x_2, 1); +x_15 = lean_ctor_get(x_2, 0); +lean_dec(x_15); +x_16 = l_Lake_JobState_merge(x_12, x_14); +x_17 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_16); +lean_ctor_set(x_2, 0, x_17); +return x_2; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_2, 1); +lean_inc(x_18); +lean_dec(x_2); +x_19 = l_Lake_JobState_merge(x_12, x_18); +x_20 = lean_unsigned_to_nat(0u); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_19); +return x_21; +} +} +} +else +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_22; uint8_t x_23; +x_22 = lean_ctor_get(x_1, 1); +lean_inc(x_22); +lean_dec(x_1); +x_23 = !lean_is_exclusive(x_2); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_24 = lean_ctor_get(x_2, 1); +x_25 = lean_ctor_get(x_2, 0); +lean_dec(x_25); +x_26 = l_Lake_JobState_merge(x_22, x_24); +x_27 = lean_unsigned_to_nat(0u); +lean_ctor_set_tag(x_2, 1); +lean_ctor_set(x_2, 1, x_26); +lean_ctor_set(x_2, 0, x_27); +return x_2; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_28 = lean_ctor_get(x_2, 1); +lean_inc(x_28); +lean_dec(x_2); +x_29 = l_Lake_JobState_merge(x_22, x_28); +x_30 = lean_unsigned_to_nat(0u); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_29); +return x_31; +} +} +else +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_1, 1); +lean_inc(x_32); +lean_dec(x_1); +x_33 = !lean_is_exclusive(x_2); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_34 = lean_ctor_get(x_2, 1); +x_35 = lean_ctor_get(x_2, 0); +lean_dec(x_35); +x_36 = l_Lake_JobState_merge(x_32, x_34); +x_37 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_36); +lean_ctor_set(x_2, 0, x_37); +return x_2; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_2, 1); +lean_inc(x_38); +lean_dec(x_2); +x_39 = l_Lake_JobState_merge(x_32, x_38); +x_40 = lean_unsigned_to_nat(0u); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_39); +return x_41; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_add___rarg___lambda__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_add___rarg___lambda__1), 2, 1); +lean_closure_set(x_3, 0, x_2); +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_3, x_4, x_5, x_6); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_add___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = lean_alloc_closure((void*)(l_Lake_BuildJob_add___rarg___lambda__2), 2, 1); +lean_closure_set(x_4, 0, x_2); +x_5 = l_Task_Priority_default; +x_6 = 1; +x_7 = lean_task_bind(x_3, x_4, x_5, x_6); +x_8 = l_Lake_instInhabitedJob___closed__3; +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_7); +lean_ctor_set(x_9, 1, x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_add(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_add___rarg), 2, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +lean_dec(x_1); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +x_8 = l_Lake_JobState_merge(x_4, x_7); +x_9 = lean_ctor_get(x_3, 1); +lean_inc(x_9); +lean_dec(x_3); +x_10 = !lean_is_exclusive(x_6); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_6, 1); +x_12 = lean_ctor_get(x_6, 0); +lean_dec(x_12); +x_13 = l_Lake_BuildTrace_mix(x_9, x_11); +x_14 = lean_box(0); +lean_ctor_set(x_6, 1, x_13); +lean_ctor_set(x_6, 0, x_14); +lean_ctor_set(x_2, 1, x_8); +return x_2; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_15 = lean_ctor_get(x_6, 1); +lean_inc(x_15); +lean_dec(x_6); +x_16 = l_Lake_BuildTrace_mix(x_9, x_15); +x_17 = lean_box(0); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_16); +lean_ctor_set(x_2, 1, x_8); +lean_ctor_set(x_2, 0, x_18); +return x_2; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_19 = lean_ctor_get(x_2, 0); +x_20 = lean_ctor_get(x_2, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_2); +x_21 = l_Lake_JobState_merge(x_4, x_20); +x_22 = lean_ctor_get(x_3, 1); +lean_inc(x_22); +lean_dec(x_3); +x_23 = lean_ctor_get(x_19, 1); +lean_inc(x_23); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_24 = x_19; +} else { + lean_dec_ref(x_19); + x_24 = lean_box(0); +} +x_25 = l_Lake_BuildTrace_mix(x_22, x_23); +x_26 = lean_box(0); +if (lean_is_scalar(x_24)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_24; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_25); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_21); +return x_28; +} +} +else +{ +lean_object* x_29; uint8_t x_30; +x_29 = lean_ctor_get(x_1, 1); +lean_inc(x_29); +lean_dec(x_1); +x_30 = !lean_is_exclusive(x_2); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_31 = lean_ctor_get(x_2, 1); +x_32 = lean_ctor_get(x_2, 0); +lean_dec(x_32); +x_33 = l_Lake_JobState_merge(x_29, x_31); +x_34 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_33); +lean_ctor_set(x_2, 0, x_34); +return x_2; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_35 = lean_ctor_get(x_2, 1); +lean_inc(x_35); +lean_dec(x_2); +x_36 = l_Lake_JobState_merge(x_29, x_35); +x_37 = lean_unsigned_to_nat(0u); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_36); +return x_38; +} +} +} +else +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_39; uint8_t x_40; +x_39 = lean_ctor_get(x_1, 1); +lean_inc(x_39); +lean_dec(x_1); +x_40 = !lean_is_exclusive(x_2); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_41 = lean_ctor_get(x_2, 1); +x_42 = lean_ctor_get(x_2, 0); +lean_dec(x_42); +x_43 = l_Lake_JobState_merge(x_39, x_41); +x_44 = lean_unsigned_to_nat(0u); +lean_ctor_set_tag(x_2, 1); +lean_ctor_set(x_2, 1, x_43); +lean_ctor_set(x_2, 0, x_44); +return x_2; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_45 = lean_ctor_get(x_2, 1); +lean_inc(x_45); +lean_dec(x_2); +x_46 = l_Lake_JobState_merge(x_39, x_45); +x_47 = lean_unsigned_to_nat(0u); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_46); +return x_48; +} +} +else +{ +lean_object* x_49; uint8_t x_50; +x_49 = lean_ctor_get(x_1, 1); +lean_inc(x_49); +lean_dec(x_1); +x_50 = !lean_is_exclusive(x_2); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_51 = lean_ctor_get(x_2, 1); +x_52 = lean_ctor_get(x_2, 0); +lean_dec(x_52); +x_53 = l_Lake_JobState_merge(x_49, x_51); +x_54 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_53); +lean_ctor_set(x_2, 0, x_54); +return x_2; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_55 = lean_ctor_get(x_2, 1); +lean_inc(x_55); +lean_dec(x_2); +x_56 = l_Lake_JobState_merge(x_49, x_55); +x_57 = lean_unsigned_to_nat(0u); +x_58 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_56); +return x_58; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix___rarg___lambda__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_mix___rarg___lambda__1), 2, 1); +lean_closure_set(x_3, 0, x_2); +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_3, x_4, x_5, x_6); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = lean_alloc_closure((void*)(l_Lake_BuildJob_mix___rarg___lambda__2), 2, 1); +lean_closure_set(x_4, 0, x_2); +x_5 = l_Task_Priority_default; +x_6 = 1; +x_7 = lean_task_bind(x_3, x_4, x_5, x_6); +x_8 = l_Lake_instInhabitedJob___closed__3; +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_7); +lean_ctor_set(x_9, 1, x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mix(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildJob_mix___rarg), 2, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +lean_dec(x_1); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +x_8 = l_Lake_JobState_merge(x_4, x_7); +x_9 = lean_ctor_get(x_3, 1); +lean_inc(x_9); +lean_dec(x_3); +x_10 = l_Lake_BuildTrace_mix(x_6, x_9); +lean_ctor_set(x_2, 1, x_8); +lean_ctor_set(x_2, 0, x_10); +return x_2; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get(x_2, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_2); +x_13 = l_Lake_JobState_merge(x_4, x_12); +x_14 = lean_ctor_get(x_3, 1); +lean_inc(x_14); +lean_dec(x_3); +x_15 = l_Lake_BuildTrace_mix(x_11, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_13); +return x_16; +} +} +else +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_1, 1); +lean_inc(x_17); +lean_dec(x_1); +x_18 = !lean_is_exclusive(x_2); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_2, 1); +x_20 = lean_ctor_get(x_2, 0); +lean_dec(x_20); +x_21 = l_Lake_JobState_merge(x_17, x_19); +x_22 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_21); +lean_ctor_set(x_2, 0, x_22); +return x_2; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_2, 1); +lean_inc(x_23); +lean_dec(x_2); +x_24 = l_Lake_JobState_merge(x_17, x_23); +x_25 = lean_unsigned_to_nat(0u); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_24); +return x_26; +} +} +} +else +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_27; uint8_t x_28; +x_27 = lean_ctor_get(x_1, 1); +lean_inc(x_27); +lean_dec(x_1); +x_28 = !lean_is_exclusive(x_2); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_29 = lean_ctor_get(x_2, 1); +x_30 = lean_ctor_get(x_2, 0); +lean_dec(x_30); +x_31 = l_Lake_JobState_merge(x_27, x_29); +x_32 = lean_unsigned_to_nat(0u); +lean_ctor_set_tag(x_2, 1); +lean_ctor_set(x_2, 1, x_31); +lean_ctor_set(x_2, 0, x_32); +return x_2; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_2, 1); +lean_inc(x_33); +lean_dec(x_2); +x_34 = l_Lake_JobState_merge(x_27, x_33); +x_35 = lean_unsigned_to_nat(0u); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_34); +return x_36; +} +} +else +{ +lean_object* x_37; uint8_t x_38; +x_37 = lean_ctor_get(x_1, 1); +lean_inc(x_37); +lean_dec(x_1); +x_38 = !lean_is_exclusive(x_2); +if (x_38 == 0) +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_39 = lean_ctor_get(x_2, 1); +x_40 = lean_ctor_get(x_2, 0); +lean_dec(x_40); +x_41 = l_Lake_JobState_merge(x_37, x_39); +x_42 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_41); +lean_ctor_set(x_2, 0, x_42); +return x_2; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_2, 1); +lean_inc(x_43); +lean_dec(x_2); +x_44 = l_Lake_JobState_merge(x_37, x_43); +x_45 = lean_unsigned_to_nat(0u); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_44); +return x_46; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___lambda__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___lambda__1), 2, 1); +lean_closure_set(x_3, 0, x_2); +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_3, x_4, x_5, x_6); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_6 = 1; +x_7 = lean_usize_sub(x_2, x_6); +x_8 = lean_array_uget(x_1, x_7); +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___lambda__2), 2, 1); +lean_closure_set(x_10, 0, x_4); +x_11 = l_Task_Priority_default; +x_12 = 1; +x_13 = lean_task_bind(x_9, x_10, x_11, x_12); +x_14 = l_Lake_instInhabitedJob___closed__3; +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +x_2 = x_7; +x_4 = x_15; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___boxed), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3___rarg(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_6 = 1; +x_7 = lean_usize_sub(x_2, x_6); +x_8 = lean_array_uget(x_1, x_7); +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___lambda__2), 2, 1); +lean_closure_set(x_10, 0, x_4); +x_11 = l_Task_Priority_default; +x_12 = 1; +x_13 = lean_task_bind(x_9, x_10, x_11, x_12); +x_14 = l_Lake_instInhabitedJob___closed__3; +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +x_2 = x_7; +x_4 = x_15; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3___rarg___boxed), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_mixList___spec__1___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_3 = l_List_redLength___rarg(x_2); +x_4 = lean_mk_empty_array_with_capacity(x_3); +lean_dec(x_3); +x_5 = l_List_toArrayAux___rarg(x_2, x_4); +x_6 = lean_array_get_size(x_5); +x_7 = lean_nat_dec_le(x_6, x_6); +if (x_7 == 0) +{ +lean_object* x_8; uint8_t x_9; +x_8 = lean_unsigned_to_nat(0u); +x_9 = lean_nat_dec_lt(x_8, x_6); +if (x_9 == 0) +{ +lean_dec(x_6); +lean_dec(x_5); +return x_1; +} +else +{ +size_t x_10; size_t x_11; lean_object* x_12; +x_10 = lean_usize_of_nat(x_6); +lean_dec(x_6); +x_11 = 0; +x_12 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg(x_5, x_10, x_11, x_1); +lean_dec(x_5); +return x_12; +} +} +else +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_unsigned_to_nat(0u); +x_14 = lean_nat_dec_lt(x_13, x_6); +if (x_14 == 0) +{ +lean_dec(x_6); +lean_dec(x_5); +return x_1; +} +else +{ +size_t x_15; size_t x_16; lean_object* x_17; +x_15 = lean_usize_of_nat(x_6); +lean_dec(x_6); +x_16 = 0; +x_17 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3___rarg(x_5, x_15, x_16, x_1); +lean_dec(x_5); +return x_17; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_mixList___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_foldrTR___at_Lake_BuildJob_mixList___spec__1___rarg), 2, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_mixList___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildTrace_nil; +x_2 = l_Lake_instInhabitedJobState___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_mixList___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_BuildJob_mixList___rarg___closed__1; +x_2 = lean_task_pure(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_mixList___rarg___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_mixList___rarg___closed__2; +x_2 = l_Lake_instInhabitedJob___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixList___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; uint8_t x_4; +x_2 = l_Lake_BuildJob_mixList___rarg___closed__3; +x_3 = l_List_foldrTR___at_Lake_BuildJob_mixList___spec__1___rarg(x_2, x_1); +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; +x_5 = lean_ctor_get(x_3, 0); +x_6 = l_Lake_BuildJob_ofJob___closed__2; +x_7 = l_Task_Priority_default; +x_8 = 0; +x_9 = lean_task_map(x_6, x_5, x_7, x_8); +lean_ctor_set(x_3, 0, x_9); +return x_3; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_10 = lean_ctor_get(x_3, 0); +x_11 = lean_ctor_get(x_3, 1); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_3); +x_12 = l_Lake_BuildJob_ofJob___closed__2; +x_13 = l_Task_Priority_default; +x_14 = 0; +x_15 = lean_task_map(x_12, x_10, x_13, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_11); +return x_16; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixList(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_mixList___rarg), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__2___rarg(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_mixList___spec__3___rarg(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +lean_dec(x_1); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +x_8 = l_Lake_JobState_merge(x_4, x_7); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = l_Lake_BuildTrace_mix(x_3, x_9); +lean_ctor_set(x_2, 1, x_8); +lean_ctor_set(x_2, 0, x_10); +return x_2; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get(x_2, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_2); +x_13 = l_Lake_JobState_merge(x_4, x_12); +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +lean_dec(x_11); +x_15 = l_Lake_BuildTrace_mix(x_3, x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_13); +return x_16; +} +} +else +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_1, 1); +lean_inc(x_17); +lean_dec(x_1); +x_18 = !lean_is_exclusive(x_2); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_2, 1); +x_20 = lean_ctor_get(x_2, 0); +lean_dec(x_20); +x_21 = l_Lake_JobState_merge(x_17, x_19); +x_22 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_21); +lean_ctor_set(x_2, 0, x_22); +return x_2; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_2, 1); +lean_inc(x_23); +lean_dec(x_2); +x_24 = l_Lake_JobState_merge(x_17, x_23); +x_25 = lean_unsigned_to_nat(0u); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_24); +return x_26; +} +} +} +else +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_27; uint8_t x_28; +x_27 = lean_ctor_get(x_1, 1); +lean_inc(x_27); +lean_dec(x_1); +x_28 = !lean_is_exclusive(x_2); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_29 = lean_ctor_get(x_2, 1); +x_30 = lean_ctor_get(x_2, 0); +lean_dec(x_30); +x_31 = l_Lake_JobState_merge(x_27, x_29); +x_32 = lean_unsigned_to_nat(0u); +lean_ctor_set_tag(x_2, 1); +lean_ctor_set(x_2, 1, x_31); +lean_ctor_set(x_2, 0, x_32); +return x_2; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_2, 1); +lean_inc(x_33); +lean_dec(x_2); +x_34 = l_Lake_JobState_merge(x_27, x_33); +x_35 = lean_unsigned_to_nat(0u); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_34); +return x_36; +} +} +else +{ +lean_object* x_37; uint8_t x_38; +x_37 = lean_ctor_get(x_1, 1); +lean_inc(x_37); +lean_dec(x_1); +x_38 = !lean_is_exclusive(x_2); +if (x_38 == 0) +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_39 = lean_ctor_get(x_2, 1); +x_40 = lean_ctor_get(x_2, 0); +lean_dec(x_40); +x_41 = l_Lake_JobState_merge(x_37, x_39); +x_42 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_2, 1, x_41); +lean_ctor_set(x_2, 0, x_42); +return x_2; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_2, 1); +lean_inc(x_43); +lean_dec(x_2); +x_44 = l_Lake_JobState_merge(x_37, x_43); +x_45 = lean_unsigned_to_nat(0u); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_44); +return x_46; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___lambda__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___lambda__1), 2, 1); +lean_closure_set(x_3, 0, x_2); +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_3, x_4, x_5, x_6); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; size_t x_14; size_t x_15; +x_6 = lean_array_uget(x_1, x_2); +x_7 = lean_ctor_get(x_4, 0); +lean_inc(x_7); +lean_dec(x_4); +x_8 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___lambda__2), 2, 1); +lean_closure_set(x_8, 0, x_6); +x_9 = l_Task_Priority_default; +x_10 = 1; +x_11 = lean_task_bind(x_7, x_8, x_9, x_10); +x_12 = l_Lake_instInhabitedJob___closed__3; +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_12); +x_14 = 1; +x_15 = lean_usize_add(x_2, x_14); +x_2 = x_15; +x_4 = x_13; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___boxed), 4, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_mixArray___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; +x_1 = l_Lake_BuildJob_ofJob___closed__2; +x_2 = l_Lake_BuildJob_mixList___rarg___closed__2; +x_3 = l_Task_Priority_default; +x_4 = 0; +x_5 = lean_task_map(x_1, x_2, x_3, x_4); +return x_5; +} +} +static lean_object* _init_l_Lake_BuildJob_mixArray___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_mixArray___rarg___closed__1; +x_2 = l_Lake_instInhabitedJob___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixArray___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; uint8_t x_4; +x_2 = lean_array_get_size(x_1); +x_3 = lean_unsigned_to_nat(0u); +x_4 = lean_nat_dec_lt(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; +lean_dec(x_2); +x_5 = l_Lake_BuildJob_mixArray___rarg___closed__2; +return x_5; +} +else +{ +uint8_t x_6; +x_6 = lean_nat_dec_le(x_2, x_2); +if (x_6 == 0) +{ +lean_object* x_7; +lean_dec(x_2); +x_7 = l_Lake_BuildJob_mixArray___rarg___closed__2; +return x_7; +} +else +{ +size_t x_8; size_t x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_8 = 0; +x_9 = lean_usize_of_nat(x_2); +lean_dec(x_2); +x_10 = l_Lake_BuildJob_mixList___rarg___closed__3; +x_11 = l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg(x_1, x_8, x_9, x_10); +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; +x_13 = lean_ctor_get(x_11, 0); +x_14 = l_Lake_BuildJob_ofJob___closed__2; +x_15 = l_Task_Priority_default; +x_16 = 0; +x_17 = lean_task_map(x_14, x_13, x_15, x_16); +lean_ctor_set(x_11, 0, x_17); +return x_11; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; +x_18 = lean_ctor_get(x_11, 0); +x_19 = lean_ctor_get(x_11, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_11); +x_20 = l_Lake_BuildJob_ofJob___closed__2; +x_21 = l_Task_Priority_default; +x_22 = 0; +x_23 = lean_task_map(x_20, x_18, x_21, x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_19); +return x_24; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixArray(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_mixArray___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_mixArray___spec__1___rarg(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_mixArray___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_BuildJob_mixArray___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = !lean_is_exclusive(x_3); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_7 = lean_ctor_get(x_3, 0); +x_8 = lean_ctor_get(x_3, 1); +x_9 = l_Lake_JobState_merge(x_5, x_8); +x_10 = lean_ctor_get(x_4, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_4, 1); +lean_inc(x_11); +lean_dec(x_4); +x_12 = !lean_is_exclusive(x_7); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_7, 0); +x_14 = lean_ctor_get(x_7, 1); +x_15 = lean_apply_2(x_2, x_10, x_13); +x_16 = l_Lake_BuildTrace_mix(x_11, x_14); +lean_ctor_set(x_7, 1, x_16); +lean_ctor_set(x_7, 0, x_15); +lean_ctor_set(x_3, 1, x_9); +return x_3; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_17 = lean_ctor_get(x_7, 0); +x_18 = lean_ctor_get(x_7, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_7); +x_19 = lean_apply_2(x_2, x_10, x_17); +x_20 = l_Lake_BuildTrace_mix(x_11, x_18); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +lean_ctor_set(x_3, 1, x_9); +lean_ctor_set(x_3, 0, x_21); +return x_3; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_22 = lean_ctor_get(x_3, 0); +x_23 = lean_ctor_get(x_3, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_3); +x_24 = l_Lake_JobState_merge(x_5, x_23); +x_25 = lean_ctor_get(x_4, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_4, 1); +lean_inc(x_26); +lean_dec(x_4); +x_27 = lean_ctor_get(x_22, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_22, 1); +lean_inc(x_28); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_29 = x_22; +} else { + lean_dec_ref(x_22); + x_29 = lean_box(0); +} +x_30 = lean_apply_2(x_2, x_25, x_27); +x_31 = l_Lake_BuildTrace_mix(x_26, x_28); +if (lean_is_scalar(x_29)) { + x_32 = lean_alloc_ctor(0, 2, 0); +} else { + x_32 = x_29; +} +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_31); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_24); +return x_33; +} +} +else +{ +lean_object* x_34; uint8_t x_35; +lean_dec(x_2); +x_34 = lean_ctor_get(x_1, 1); +lean_inc(x_34); +lean_dec(x_1); +x_35 = !lean_is_exclusive(x_3); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = lean_ctor_get(x_3, 1); +x_37 = lean_ctor_get(x_3, 0); +lean_dec(x_37); +x_38 = l_Lake_JobState_merge(x_34, x_36); +x_39 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_3, 1, x_38); +lean_ctor_set(x_3, 0, x_39); +return x_3; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_40 = lean_ctor_get(x_3, 1); +lean_inc(x_40); +lean_dec(x_3); +x_41 = l_Lake_JobState_merge(x_34, x_40); +x_42 = lean_unsigned_to_nat(0u); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_41); +return x_43; +} +} +} +else +{ +lean_dec(x_2); +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_44; uint8_t x_45; +x_44 = lean_ctor_get(x_1, 1); +lean_inc(x_44); +lean_dec(x_1); +x_45 = !lean_is_exclusive(x_3); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_46 = lean_ctor_get(x_3, 1); +x_47 = lean_ctor_get(x_3, 0); +lean_dec(x_47); +x_48 = l_Lake_JobState_merge(x_44, x_46); +x_49 = lean_unsigned_to_nat(0u); +lean_ctor_set_tag(x_3, 1); +lean_ctor_set(x_3, 1, x_48); +lean_ctor_set(x_3, 0, x_49); +return x_3; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_50 = lean_ctor_get(x_3, 1); +lean_inc(x_50); +lean_dec(x_3); +x_51 = l_Lake_JobState_merge(x_44, x_50); +x_52 = lean_unsigned_to_nat(0u); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_51); +return x_53; +} +} +else +{ +lean_object* x_54; uint8_t x_55; +x_54 = lean_ctor_get(x_1, 1); +lean_inc(x_54); +lean_dec(x_1); +x_55 = !lean_is_exclusive(x_3); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_3, 1); +x_57 = lean_ctor_get(x_3, 0); +lean_dec(x_57); +x_58 = l_Lake_JobState_merge(x_54, x_56); +x_59 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_3, 1, x_58); +lean_ctor_set(x_3, 0, x_59); +return x_3; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_60 = lean_ctor_get(x_3, 1); +lean_inc(x_60); +lean_dec(x_3); +x_61 = l_Lake_JobState_merge(x_54, x_60); +x_62 = lean_unsigned_to_nat(0u); +x_63 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_61); +return x_63; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; +x_4 = lean_alloc_closure((void*)(l_Lake_BuildJob_zipWith___rarg___lambda__1), 3, 2); +lean_closure_set(x_4, 0, x_3); +lean_closure_set(x_4, 1, x_1); +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +lean_dec(x_2); +x_6 = l_Task_Priority_default; +x_7 = 0; +x_8 = lean_task_map(x_4, x_5, x_6, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_2, 0); +lean_inc(x_4); +lean_dec(x_2); +x_5 = lean_alloc_closure((void*)(l_Lake_BuildJob_zipWith___rarg___lambda__2), 3, 2); +lean_closure_set(x_5, 0, x_1); +lean_closure_set(x_5, 1, x_3); +x_6 = l_Task_Priority_default; +x_7 = 1; +x_8 = lean_task_bind(x_4, x_5, x_6, x_7); +x_9 = l_Lake_instInhabitedJob___closed__3; +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_8); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_zipWith(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_BuildJob_zipWith___rarg), 3, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___rarg(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = lean_usize_dec_eq(x_3, x_4); +if (x_6 == 0) +{ +size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_10; +x_7 = 1; +x_8 = lean_usize_sub(x_3, x_7); +x_9 = lean_array_uget(x_2, x_8); +lean_inc(x_1); +x_10 = l_Lake_BuildJob_zipWith___rarg(x_1, x_9, x_5); +x_3 = x_8; +x_5 = x_10; +goto _start; +} +else +{ +lean_dec(x_1); +return x_5; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___rarg(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = lean_usize_dec_eq(x_3, x_4); +if (x_6 == 0) +{ +size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_10; +x_7 = 1; +x_8 = lean_usize_sub(x_3, x_7); +x_9 = lean_array_uget(x_2, x_8); +lean_inc(x_1); +x_10 = l_Lake_BuildJob_zipWith___rarg(x_1, x_9, x_5); +x_3 = x_8; +x_5 = x_10; +goto _start; +} +else +{ +lean_dec(x_1); +return x_5; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_4 = l_List_redLength___rarg(x_3); +x_5 = lean_mk_empty_array_with_capacity(x_4); +lean_dec(x_4); +x_6 = l_List_toArrayAux___rarg(x_3, x_5); +x_7 = lean_array_get_size(x_6); +x_8 = lean_nat_dec_le(x_7, x_7); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_unsigned_to_nat(0u); +x_10 = lean_nat_dec_lt(x_9, x_7); +if (x_10 == 0) +{ +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +return x_2; +} +else +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_usize_of_nat(x_7); +lean_dec(x_7); +x_12 = 0; +x_13 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___rarg(x_1, x_6, x_11, x_12, x_2); +lean_dec(x_6); +return x_13; +} +} +else +{ +lean_object* x_14; uint8_t x_15; +x_14 = lean_unsigned_to_nat(0u); +x_15 = lean_nat_dec_lt(x_14, x_7); +if (x_15 == 0) +{ +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +return x_2; +} +else +{ +size_t x_16; size_t x_17; lean_object* x_18; +x_16 = lean_usize_of_nat(x_7); +lean_dec(x_7); +x_17 = 0; +x_18 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___rarg(x_1, x_6, x_16, x_17, x_2); +lean_dec(x_6); +return x_18; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___rarg), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___lambda__1), 2, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = 1; +x_7 = lean_usize_sub(x_2, x_6); +x_8 = lean_array_uget(x_1, x_7); +x_9 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___closed__1; +x_10 = l_Lake_BuildJob_zipWith___rarg(x_9, x_8, x_4); +x_2 = x_7; +x_4 = x_10; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___boxed), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6___rarg(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = 1; +x_7 = lean_usize_sub(x_2, x_6); +x_8 = lean_array_uget(x_1, x_7); +x_9 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___closed__1; +x_10 = l_Lake_BuildJob_zipWith___rarg(x_9, x_8, x_4); +x_2 = x_7; +x_4 = x_10; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6___rarg___boxed), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___at_Lake_BuildJob_collectList___spec__4___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_3 = l_List_redLength___rarg(x_2); +x_4 = lean_mk_empty_array_with_capacity(x_3); +lean_dec(x_3); +x_5 = l_List_toArrayAux___rarg(x_2, x_4); +x_6 = lean_array_get_size(x_5); +x_7 = lean_nat_dec_le(x_6, x_6); +if (x_7 == 0) +{ +lean_object* x_8; uint8_t x_9; +x_8 = lean_unsigned_to_nat(0u); +x_9 = lean_nat_dec_lt(x_8, x_6); +if (x_9 == 0) +{ +lean_dec(x_6); +lean_dec(x_5); +return x_1; +} +else +{ +size_t x_10; size_t x_11; lean_object* x_12; +x_10 = lean_usize_of_nat(x_6); +lean_dec(x_6); +x_11 = 0; +x_12 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg(x_5, x_10, x_11, x_1); +lean_dec(x_5); +return x_12; +} +} +else +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_unsigned_to_nat(0u); +x_14 = lean_nat_dec_lt(x_13, x_6); +if (x_14 == 0) +{ +lean_dec(x_6); +lean_dec(x_5); +return x_1; +} +else +{ +size_t x_15; size_t x_16; lean_object* x_17; +x_15 = lean_usize_of_nat(x_6); +lean_dec(x_6); +x_16 = 0; +x_17 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6___rarg(x_5, x_15, x_16, x_1); +lean_dec(x_5); +return x_17; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___at_Lake_BuildJob_collectList___spec__4(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___at_Lake_BuildJob_collectList___spec__4___rarg), 2, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_collectList___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_collectList___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_collectList___rarg___closed__1; +x_2 = l_Lake_instInhabitedJobState___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_collectList___rarg___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_BuildJob_collectList___rarg___closed__2; +x_2 = lean_task_pure(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_collectList___rarg___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_collectList___rarg___closed__3; +x_2 = l_Lake_instInhabitedJob___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectList___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_BuildJob_collectList___rarg___closed__4; +x_3 = l_List_foldrTR___at_Lake_BuildJob_collectList___spec__1___at_Lake_BuildJob_collectList___spec__4___rarg(x_2, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectList(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_collectList___rarg), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +size_t x_6; size_t x_7; lean_object* x_8; +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_8 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___rarg(x_1, x_2, x_6, x_7, x_5); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +size_t x_6; size_t x_7; lean_object* x_8; +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_8 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___rarg(x_1, x_2, x_6, x_7, x_5); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__3___at_Lake_BuildJob_collectList___spec__6___rarg(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___rarg(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = lean_usize_dec_eq(x_3, x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; size_t x_9; size_t x_10; +x_7 = lean_array_uget(x_2, x_3); +lean_inc(x_1); +x_8 = l_Lake_BuildJob_zipWith___rarg(x_1, x_5, x_7); +x_9 = 1; +x_10 = lean_usize_add(x_3, x_9); +x_3 = x_10; +x_5 = x_8; +goto _start; +} +else +{ +lean_dec(x_1); +return x_5; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___rarg___boxed), 5, 0); +return x_2; +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Array_push___boxed), 3, 1); +lean_closure_set(x_1, 0, lean_box(0)); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; size_t x_9; size_t x_10; +x_6 = lean_array_uget(x_1, x_2); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___closed__1; +x_8 = l_Lake_BuildJob_zipWith___rarg(x_7, x_4, x_6); +x_9 = 1; +x_10 = lean_usize_add(x_2, x_9); +x_2 = x_10; +x_4 = x_8; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___boxed), 4, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_collectArray___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_JobState_log___default___closed__1; +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_collectArray___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_collectArray___rarg___closed__1; +x_2 = l_Lake_instInhabitedJobState___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildJob_collectArray___rarg___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_BuildJob_collectArray___rarg___closed__2; +x_2 = lean_task_pure(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildJob_collectArray___rarg___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildJob_collectArray___rarg___closed__3; +x_2 = l_Lake_instInhabitedJob___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectArray___rarg(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; uint8_t x_4; +x_2 = lean_array_get_size(x_1); +x_3 = lean_unsigned_to_nat(0u); +x_4 = lean_nat_dec_lt(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; +lean_dec(x_2); +x_5 = l_Lake_BuildJob_collectArray___rarg___closed__4; +return x_5; +} +else +{ +uint8_t x_6; +x_6 = lean_nat_dec_le(x_2, x_2); +if (x_6 == 0) +{ +lean_object* x_7; +lean_dec(x_2); +x_7 = l_Lake_BuildJob_collectArray___rarg___closed__4; +return x_7; +} +else +{ +size_t x_8; size_t x_9; lean_object* x_10; lean_object* x_11; +x_8 = 0; +x_9 = lean_usize_of_nat(x_2); +lean_dec(x_2); +x_10 = l_Lake_BuildJob_collectArray___rarg___closed__4; +x_11 = l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg(x_1, x_8, x_9, x_10); +return x_11; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectArray(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildJob_collectArray___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +size_t x_6; size_t x_7; lean_object* x_8; +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_8 = l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___rarg(x_1, x_2, x_6, x_7, x_5); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildJob_collectArray___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_BuildJob_collectArray___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Task(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Basic(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Job(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Task(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Basic(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_JobAction_noConfusion___rarg___closed__1 = _init_l_Lake_JobAction_noConfusion___rarg___closed__1(); +lean_mark_persistent(l_Lake_JobAction_noConfusion___rarg___closed__1); +l_Lake_instInhabitedJobAction = _init_l_Lake_instInhabitedJobAction(); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__1 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__1(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__1); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__2 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__2(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__2); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__3); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__4 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__4(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__4); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__5 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__5(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__5); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__6); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__7 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__7(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__7); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__8 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__8(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__8); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__9 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__9(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__9); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__10 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__10(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__10); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__11 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__11(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__11); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__12 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__12(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__12); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__13 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__13(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__13); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__14 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__14(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__14); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__15 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__15(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__15); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__16 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__16(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__16); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__17 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__17(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__17); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__18 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__18(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__18); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__19 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__19(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__19); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__20 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__20(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__20); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__21 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__21(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__21); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__22 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__22(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__22); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__23 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__23(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__23); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__24 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__24(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__24); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__25 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__25(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__25); +l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__26 = _init_l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__26(); +lean_mark_persistent(l___private_Lake_Build_Job_0__Lake_reprJobAction____x40_Lake_Build_Job___hyg_18____closed__26); +l_Lake_instReprJobAction___closed__1 = _init_l_Lake_instReprJobAction___closed__1(); +lean_mark_persistent(l_Lake_instReprJobAction___closed__1); +l_Lake_instReprJobAction = _init_l_Lake_instReprJobAction(); +lean_mark_persistent(l_Lake_instReprJobAction); +l_Lake_instOrdJobAction___closed__1 = _init_l_Lake_instOrdJobAction___closed__1(); +lean_mark_persistent(l_Lake_instOrdJobAction___closed__1); +l_Lake_instOrdJobAction = _init_l_Lake_instOrdJobAction(); +lean_mark_persistent(l_Lake_instOrdJobAction); +l_Lake_instLTJobAction = _init_l_Lake_instLTJobAction(); +lean_mark_persistent(l_Lake_instLTJobAction); +l_Lake_instLEJobAction = _init_l_Lake_instLEJobAction(); +lean_mark_persistent(l_Lake_instLEJobAction); +l_Lake_JobAction_verb___closed__1 = _init_l_Lake_JobAction_verb___closed__1(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__1); +l_Lake_JobAction_verb___closed__2 = _init_l_Lake_JobAction_verb___closed__2(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__2); +l_Lake_JobAction_verb___closed__3 = _init_l_Lake_JobAction_verb___closed__3(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__3); +l_Lake_JobAction_verb___closed__4 = _init_l_Lake_JobAction_verb___closed__4(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__4); +l_Lake_JobAction_verb___closed__5 = _init_l_Lake_JobAction_verb___closed__5(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__5); +l_Lake_JobAction_verb___closed__6 = _init_l_Lake_JobAction_verb___closed__6(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__6); +l_Lake_JobAction_verb___closed__7 = _init_l_Lake_JobAction_verb___closed__7(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__7); +l_Lake_JobAction_verb___closed__8 = _init_l_Lake_JobAction_verb___closed__8(); +lean_mark_persistent(l_Lake_JobAction_verb___closed__8); +l_Lake_JobState_log___default___closed__1 = _init_l_Lake_JobState_log___default___closed__1(); +lean_mark_persistent(l_Lake_JobState_log___default___closed__1); +l_Lake_JobState_log___default = _init_l_Lake_JobState_log___default(); +lean_mark_persistent(l_Lake_JobState_log___default); +l_Lake_JobState_action___default = _init_l_Lake_JobState_action___default(); +l_Lake_instInhabitedJobState___closed__1 = _init_l_Lake_instInhabitedJobState___closed__1(); +lean_mark_persistent(l_Lake_instInhabitedJobState___closed__1); +l_Lake_instInhabitedJobState = _init_l_Lake_instInhabitedJobState(); +lean_mark_persistent(l_Lake_instInhabitedJobState); +l_Lake_instMonadStateOfLogJobM___closed__1 = _init_l_Lake_instMonadStateOfLogJobM___closed__1(); +lean_mark_persistent(l_Lake_instMonadStateOfLogJobM___closed__1); +l_Lake_instMonadStateOfLogJobM___closed__2 = _init_l_Lake_instMonadStateOfLogJobM___closed__2(); +lean_mark_persistent(l_Lake_instMonadStateOfLogJobM___closed__2); +l_Lake_instMonadStateOfLogJobM___closed__3 = _init_l_Lake_instMonadStateOfLogJobM___closed__3(); +lean_mark_persistent(l_Lake_instMonadStateOfLogJobM___closed__3); +l_Lake_instMonadStateOfLogJobM___closed__4 = _init_l_Lake_instMonadStateOfLogJobM___closed__4(); +lean_mark_persistent(l_Lake_instMonadStateOfLogJobM___closed__4); +l_Lake_instMonadStateOfLogJobM = _init_l_Lake_instMonadStateOfLogJobM(); +lean_mark_persistent(l_Lake_instMonadStateOfLogJobM); +l_Lake_instMonadStateOfJobStateJobM___closed__1 = _init_l_Lake_instMonadStateOfJobStateJobM___closed__1(); +lean_mark_persistent(l_Lake_instMonadStateOfJobStateJobM___closed__1); +l_Lake_instMonadStateOfJobStateJobM___closed__2 = _init_l_Lake_instMonadStateOfJobStateJobM___closed__2(); +lean_mark_persistent(l_Lake_instMonadStateOfJobStateJobM___closed__2); +l_Lake_instMonadStateOfJobStateJobM___closed__3 = _init_l_Lake_instMonadStateOfJobStateJobM___closed__3(); +lean_mark_persistent(l_Lake_instMonadStateOfJobStateJobM___closed__3); +l_Lake_instMonadStateOfJobStateJobM = _init_l_Lake_instMonadStateOfJobStateJobM(); +lean_mark_persistent(l_Lake_instMonadStateOfJobStateJobM); +l_Lake_instMonadLogJobM___closed__1 = _init_l_Lake_instMonadLogJobM___closed__1(); +lean_mark_persistent(l_Lake_instMonadLogJobM___closed__1); +l_Lake_instMonadLogJobM = _init_l_Lake_instMonadLogJobM(); +lean_mark_persistent(l_Lake_instMonadLogJobM); +l_Lake_instAlternativeJobM___closed__1 = _init_l_Lake_instAlternativeJobM___closed__1(); +lean_mark_persistent(l_Lake_instAlternativeJobM___closed__1); +l_Lake_instAlternativeJobM___closed__2 = _init_l_Lake_instAlternativeJobM___closed__2(); +lean_mark_persistent(l_Lake_instAlternativeJobM___closed__2); +l_Lake_instAlternativeJobM___closed__3 = _init_l_Lake_instAlternativeJobM___closed__3(); +lean_mark_persistent(l_Lake_instAlternativeJobM___closed__3); +l_Lake_instAlternativeJobM___closed__4 = _init_l_Lake_instAlternativeJobM___closed__4(); +lean_mark_persistent(l_Lake_instAlternativeJobM___closed__4); +l_Lake_instAlternativeJobM___closed__5 = _init_l_Lake_instAlternativeJobM___closed__5(); +lean_mark_persistent(l_Lake_instAlternativeJobM___closed__5); +l_Lake_instAlternativeJobM = _init_l_Lake_instAlternativeJobM(); +lean_mark_persistent(l_Lake_instAlternativeJobM); +l_Lake_instInhabitedJob___closed__1 = _init_l_Lake_instInhabitedJob___closed__1(); +lean_mark_persistent(l_Lake_instInhabitedJob___closed__1); +l_Lake_instInhabitedJob___closed__2 = _init_l_Lake_instInhabitedJob___closed__2(); +lean_mark_persistent(l_Lake_instInhabitedJob___closed__2); +l_Lake_instInhabitedJob___closed__3 = _init_l_Lake_instInhabitedJob___closed__3(); +lean_mark_persistent(l_Lake_instInhabitedJob___closed__3); +l_Lake_instInhabitedJob___closed__4 = _init_l_Lake_instInhabitedJob___closed__4(); +lean_mark_persistent(l_Lake_instInhabitedJob___closed__4); +l_Lake_instInhabitedBundledJob = _init_l_Lake_instInhabitedBundledJob(); +lean_mark_persistent(l_Lake_instInhabitedBundledJob); +l_Lake_OpaqueJob_instCoeBundledJob___closed__1 = _init_l_Lake_OpaqueJob_instCoeBundledJob___closed__1(); +lean_mark_persistent(l_Lake_OpaqueJob_instCoeBundledJob___closed__1); +l_Lake_OpaqueJob_instCoeBundledJob = _init_l_Lake_OpaqueJob_instCoeBundledJob(); +lean_mark_persistent(l_Lake_OpaqueJob_instCoeBundledJob); +l_Lake_OpaqueJob_instCoeBundledJob__1___closed__1 = _init_l_Lake_OpaqueJob_instCoeBundledJob__1___closed__1(); +lean_mark_persistent(l_Lake_OpaqueJob_instCoeBundledJob__1___closed__1); +l_Lake_OpaqueJob_instCoeBundledJob__1 = _init_l_Lake_OpaqueJob_instCoeBundledJob__1(); +lean_mark_persistent(l_Lake_OpaqueJob_instCoeBundledJob__1); +l_Lake_Job_instFunctor___closed__1 = _init_l_Lake_Job_instFunctor___closed__1(); +lean_mark_persistent(l_Lake_Job_instFunctor___closed__1); +l_Lake_Job_instFunctor___closed__2 = _init_l_Lake_Job_instFunctor___closed__2(); +lean_mark_persistent(l_Lake_Job_instFunctor___closed__2); +l_Lake_Job_instFunctor___closed__3 = _init_l_Lake_Job_instFunctor___closed__3(); +lean_mark_persistent(l_Lake_Job_instFunctor___closed__3); +l_Lake_Job_instFunctor = _init_l_Lake_Job_instFunctor(); +lean_mark_persistent(l_Lake_Job_instFunctor); +l_Lake_Job_renew___rarg___closed__1 = _init_l_Lake_Job_renew___rarg___closed__1(); +lean_mark_persistent(l_Lake_Job_renew___rarg___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__2 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__2(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__3 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__3(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__3); +l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__4 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__4(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__4); +l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Job_async___spec__1___rarg___closed__5); +l_Lake_Job_async___rarg___lambda__2___closed__1 = _init_l_Lake_Job_async___rarg___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_Job_async___rarg___lambda__2___closed__1); +l_Lake_BuildJob_ofJob___closed__1 = _init_l_Lake_BuildJob_ofJob___closed__1(); +lean_mark_persistent(l_Lake_BuildJob_ofJob___closed__1); +l_Lake_BuildJob_ofJob___closed__2 = _init_l_Lake_BuildJob_ofJob___closed__2(); +lean_mark_persistent(l_Lake_BuildJob_ofJob___closed__2); +l_Lake_BuildJob_nil___closed__1 = _init_l_Lake_BuildJob_nil___closed__1(); +lean_mark_persistent(l_Lake_BuildJob_nil___closed__1); +l_Lake_BuildJob_nil___closed__2 = _init_l_Lake_BuildJob_nil___closed__2(); +lean_mark_persistent(l_Lake_BuildJob_nil___closed__2); +l_Lake_BuildJob_nil___closed__3 = _init_l_Lake_BuildJob_nil___closed__3(); +lean_mark_persistent(l_Lake_BuildJob_nil___closed__3); +l_Lake_BuildJob_nil___closed__4 = _init_l_Lake_BuildJob_nil___closed__4(); +lean_mark_persistent(l_Lake_BuildJob_nil___closed__4); +l_Lake_BuildJob_nil = _init_l_Lake_BuildJob_nil(); +lean_mark_persistent(l_Lake_BuildJob_nil); +l_Lake_BuildJob_instFunctor___closed__1 = _init_l_Lake_BuildJob_instFunctor___closed__1(); +lean_mark_persistent(l_Lake_BuildJob_instFunctor___closed__1); +l_Lake_BuildJob_instFunctor___closed__2 = _init_l_Lake_BuildJob_instFunctor___closed__2(); +lean_mark_persistent(l_Lake_BuildJob_instFunctor___closed__2); +l_Lake_BuildJob_instFunctor___closed__3 = _init_l_Lake_BuildJob_instFunctor___closed__3(); +lean_mark_persistent(l_Lake_BuildJob_instFunctor___closed__3); +l_Lake_BuildJob_instFunctor = _init_l_Lake_BuildJob_instFunctor(); +lean_mark_persistent(l_Lake_BuildJob_instFunctor); +l_Lake_BuildJob_mixList___rarg___closed__1 = _init_l_Lake_BuildJob_mixList___rarg___closed__1(); +lean_mark_persistent(l_Lake_BuildJob_mixList___rarg___closed__1); +l_Lake_BuildJob_mixList___rarg___closed__2 = _init_l_Lake_BuildJob_mixList___rarg___closed__2(); +lean_mark_persistent(l_Lake_BuildJob_mixList___rarg___closed__2); +l_Lake_BuildJob_mixList___rarg___closed__3 = _init_l_Lake_BuildJob_mixList___rarg___closed__3(); +lean_mark_persistent(l_Lake_BuildJob_mixList___rarg___closed__3); +l_Lake_BuildJob_mixArray___rarg___closed__1 = _init_l_Lake_BuildJob_mixArray___rarg___closed__1(); +lean_mark_persistent(l_Lake_BuildJob_mixArray___rarg___closed__1); +l_Lake_BuildJob_mixArray___rarg___closed__2 = _init_l_Lake_BuildJob_mixArray___rarg___closed__2(); +lean_mark_persistent(l_Lake_BuildJob_mixArray___rarg___closed__2); +l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___closed__1 = _init_l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___closed__1(); +lean_mark_persistent(l_Array_foldrMUnsafe_fold___at_Lake_BuildJob_collectList___spec__2___at_Lake_BuildJob_collectList___spec__5___rarg___closed__1); +l_Lake_BuildJob_collectList___rarg___closed__1 = _init_l_Lake_BuildJob_collectList___rarg___closed__1(); +lean_mark_persistent(l_Lake_BuildJob_collectList___rarg___closed__1); +l_Lake_BuildJob_collectList___rarg___closed__2 = _init_l_Lake_BuildJob_collectList___rarg___closed__2(); +lean_mark_persistent(l_Lake_BuildJob_collectList___rarg___closed__2); +l_Lake_BuildJob_collectList___rarg___closed__3 = _init_l_Lake_BuildJob_collectList___rarg___closed__3(); +lean_mark_persistent(l_Lake_BuildJob_collectList___rarg___closed__3); +l_Lake_BuildJob_collectList___rarg___closed__4 = _init_l_Lake_BuildJob_collectList___rarg___closed__4(); +lean_mark_persistent(l_Lake_BuildJob_collectList___rarg___closed__4); +l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___closed__1 = _init_l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___closed__1(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_BuildJob_collectArray___spec__1___at_Lake_BuildJob_collectArray___spec__2___rarg___closed__1); +l_Lake_BuildJob_collectArray___rarg___closed__1 = _init_l_Lake_BuildJob_collectArray___rarg___closed__1(); +lean_mark_persistent(l_Lake_BuildJob_collectArray___rarg___closed__1); +l_Lake_BuildJob_collectArray___rarg___closed__2 = _init_l_Lake_BuildJob_collectArray___rarg___closed__2(); +lean_mark_persistent(l_Lake_BuildJob_collectArray___rarg___closed__2); +l_Lake_BuildJob_collectArray___rarg___closed__3 = _init_l_Lake_BuildJob_collectArray___rarg___closed__3(); +lean_mark_persistent(l_Lake_BuildJob_collectArray___rarg___closed__3); +l_Lake_BuildJob_collectArray___rarg___closed__4 = _init_l_Lake_BuildJob_collectArray___rarg___closed__4(); +lean_mark_persistent(l_Lake_BuildJob_collectArray___rarg___closed__4); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Key.c b/stage0/stdlib/Lake/Build/Key.c new file mode 100644 index 0000000000..bb25c3f46e --- /dev/null +++ b/stage0/stdlib/Lake/Build/Key.c @@ -0,0 +1,1484 @@ +// Lean compiler output +// Module: Lake.Build.Key +// Imports: Init Lake.Util.Name +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +LEAN_EXPORT uint64_t l___private_Lake_Build_Key_0__Lake_hashBuildKey____x40_Lake_Build_Key___hyg_1274_(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildKey_instLawfulCmpEqQuickCmp; +lean_object* l_Lean_Name_reprPrec(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__6; +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_hashBuildKey____x40_Lake_Build_Key___hyg_1274____boxed(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325____boxed(lean_object*, lean_object*); +uint64_t lean_uint64_mix_hash(uint64_t, uint64_t); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__8; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__9; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__14; +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____boxed(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__12; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__3; +LEAN_EXPORT lean_object* l_Lake_BuildKey_quickCmp___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_instInhabitedBuildKey___closed__1; +static lean_object* l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__2; +lean_object* lean_nat_to_int(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instReprBuildKey; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__1; +static lean_object* l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__1; +LEAN_EXPORT uint8_t l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(lean_object*, lean_object*); +lean_object* l_Lean_Name_num___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildKey_toSimpleString(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildKey_toSimpleString_eraseHead(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildKey_toString(lean_object*); +uint8_t lean_name_eq(lean_object*, lean_object*); +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +static lean_object* l_Lake_BuildKey_toString___closed__1; +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92_(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instInhabitedBuildKey; +LEAN_EXPORT lean_object* l_Lake_instHashableBuildKey; +LEAN_EXPORT lean_object* l_Lake_instDecidableEqBuildKey___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildKey_instToString(lean_object*); +static lean_object* l_Lake_BuildKey_toString___closed__3; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__11; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__7; +uint64_t l_Lean_Name_hash___override(lean_object*); +lean_object* l_Repr_addAppParen(lean_object*, lean_object*); +static lean_object* l_Lake_instReprBuildKey___closed__1; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__10; +static lean_object* l_Lake_instHashableBuildKey___closed__1; +uint8_t l_Lean_Name_quickCmp(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter___rarg(uint8_t, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +lean_object* lean_string_append(lean_object*, lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lake_BuildKey_quickCmp(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__13; +LEAN_EXPORT uint8_t l_Lake_instDecidableEqBuildKey(lean_object*, lean_object*); +static lean_object* l_Lake_BuildKey_toString___closed__4; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +static lean_object* l_Lake_BuildKey_toString___closed__5; +static lean_object* l_Lake_BuildKey_toString___closed__2; +static lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__2; +static lean_object* _init_l_Lake_instInhabitedBuildKey___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_box(0); +x_2 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_2, 0, x_1); +lean_ctor_set(x_2, 1, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_instInhabitedBuildKey() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instInhabitedBuildKey___closed__1; +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.BuildKey.moduleFacet", 25); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__1; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__2; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(2u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.BuildKey.packageFacet", 26); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__6; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__7; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.BuildKey.targetFacet", 25); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__9; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__10; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__12() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.BuildKey.customTarget", 26); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__12; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__13; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92_(lean_object* x_1, lean_object* x_2) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_1); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_unsigned_to_nat(1024u); +x_7 = lean_nat_dec_le(x_6, x_2); +x_8 = l_Lean_Name_reprPrec(x_4, x_6); +x_9 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__3; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_8); +lean_ctor_set(x_1, 0, x_9); +x_10 = lean_box(1); +x_11 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_11, 0, x_1); +lean_ctor_set(x_11, 1, x_10); +x_12 = l_Lean_Name_reprPrec(x_5, x_6); +x_13 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_12); +if (x_7 == 0) +{ +lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; +x_14 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +x_15 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +x_16 = 0; +x_17 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set_uint8(x_17, sizeof(void*)*1, x_16); +x_18 = l_Repr_addAppParen(x_17, x_2); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; +x_19 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +x_20 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_13); +x_21 = 0; +x_22 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set_uint8(x_22, sizeof(void*)*1, x_21); +x_23 = l_Repr_addAppParen(x_22, x_2); +return x_23; +} +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_24 = lean_ctor_get(x_1, 0); +x_25 = lean_ctor_get(x_1, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_1); +x_26 = lean_unsigned_to_nat(1024u); +x_27 = lean_nat_dec_le(x_26, x_2); +x_28 = l_Lean_Name_reprPrec(x_24, x_26); +x_29 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__3; +x_30 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_28); +x_31 = lean_box(1); +x_32 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_31); +x_33 = l_Lean_Name_reprPrec(x_25, x_26); +x_34 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +if (x_27 == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; +x_35 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +x_36 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_34); +x_37 = 0; +x_38 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set_uint8(x_38, sizeof(void*)*1, x_37); +x_39 = l_Repr_addAppParen(x_38, x_2); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; uint8_t x_42; lean_object* x_43; lean_object* x_44; +x_40 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +x_41 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_34); +x_42 = 0; +x_43 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set_uint8(x_43, sizeof(void*)*1, x_42); +x_44 = l_Repr_addAppParen(x_43, x_2); +return x_44; +} +} +} +case 1: +{ +uint8_t x_45; +x_45 = !lean_is_exclusive(x_1); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_46 = lean_ctor_get(x_1, 0); +x_47 = lean_ctor_get(x_1, 1); +x_48 = lean_unsigned_to_nat(1024u); +x_49 = lean_nat_dec_le(x_48, x_2); +x_50 = l_Lean_Name_reprPrec(x_46, x_48); +x_51 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__8; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_50); +lean_ctor_set(x_1, 0, x_51); +x_52 = lean_box(1); +x_53 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_53, 0, x_1); +lean_ctor_set(x_53, 1, x_52); +x_54 = l_Lean_Name_reprPrec(x_47, x_48); +x_55 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +if (x_49 == 0) +{ +lean_object* x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; +x_56 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +x_57 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_55); +x_58 = 0; +x_59 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_59, 0, x_57); +lean_ctor_set_uint8(x_59, sizeof(void*)*1, x_58); +x_60 = l_Repr_addAppParen(x_59, x_2); +return x_60; +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +x_62 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_55); +x_63 = 0; +x_64 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set_uint8(x_64, sizeof(void*)*1, x_63); +x_65 = l_Repr_addAppParen(x_64, x_2); +return x_65; +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_66 = lean_ctor_get(x_1, 0); +x_67 = lean_ctor_get(x_1, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_1); +x_68 = lean_unsigned_to_nat(1024u); +x_69 = lean_nat_dec_le(x_68, x_2); +x_70 = l_Lean_Name_reprPrec(x_66, x_68); +x_71 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__8; +x_72 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_70); +x_73 = lean_box(1); +x_74 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_74, 0, x_72); +lean_ctor_set(x_74, 1, x_73); +x_75 = l_Lean_Name_reprPrec(x_67, x_68); +x_76 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +if (x_69 == 0) +{ +lean_object* x_77; lean_object* x_78; uint8_t x_79; lean_object* x_80; lean_object* x_81; +x_77 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +x_78 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_76); +x_79 = 0; +x_80 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_79); +x_81 = l_Repr_addAppParen(x_80, x_2); +return x_81; +} +else +{ +lean_object* x_82; lean_object* x_83; uint8_t x_84; lean_object* x_85; lean_object* x_86; +x_82 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +x_83 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_76); +x_84 = 0; +x_85 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_85, 0, x_83); +lean_ctor_set_uint8(x_85, sizeof(void*)*1, x_84); +x_86 = l_Repr_addAppParen(x_85, x_2); +return x_86; +} +} +} +case 2: +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_87 = lean_ctor_get(x_1, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_1, 1); +lean_inc(x_88); +x_89 = lean_ctor_get(x_1, 2); +lean_inc(x_89); +lean_dec(x_1); +x_90 = lean_unsigned_to_nat(1024u); +x_91 = lean_nat_dec_le(x_90, x_2); +x_92 = l_Lean_Name_reprPrec(x_87, x_90); +x_93 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__11; +x_94 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_92); +x_95 = lean_box(1); +x_96 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_96, 0, x_94); +lean_ctor_set(x_96, 1, x_95); +x_97 = l_Lean_Name_reprPrec(x_88, x_90); +x_98 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +x_99 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_99, 0, x_98); +lean_ctor_set(x_99, 1, x_95); +x_100 = l_Lean_Name_reprPrec(x_89, x_90); +x_101 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +if (x_91 == 0) +{ +lean_object* x_102; lean_object* x_103; uint8_t x_104; lean_object* x_105; lean_object* x_106; +x_102 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +x_103 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_101); +x_104 = 0; +x_105 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_105, 0, x_103); +lean_ctor_set_uint8(x_105, sizeof(void*)*1, x_104); +x_106 = l_Repr_addAppParen(x_105, x_2); +return x_106; +} +else +{ +lean_object* x_107; lean_object* x_108; uint8_t x_109; lean_object* x_110; lean_object* x_111; +x_107 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +x_108 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_108, 0, x_107); +lean_ctor_set(x_108, 1, x_101); +x_109 = 0; +x_110 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_110, 0, x_108); +lean_ctor_set_uint8(x_110, sizeof(void*)*1, x_109); +x_111 = l_Repr_addAppParen(x_110, x_2); +return x_111; +} +} +default: +{ +uint8_t x_112; +x_112 = !lean_is_exclusive(x_1); +if (x_112 == 0) +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t 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_113 = lean_ctor_get(x_1, 0); +x_114 = lean_ctor_get(x_1, 1); +x_115 = lean_unsigned_to_nat(1024u); +x_116 = lean_nat_dec_le(x_115, x_2); +x_117 = l_Lean_Name_reprPrec(x_113, x_115); +x_118 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__14; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_117); +lean_ctor_set(x_1, 0, x_118); +x_119 = lean_box(1); +x_120 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_120, 0, x_1); +lean_ctor_set(x_120, 1, x_119); +x_121 = l_Lean_Name_reprPrec(x_114, x_115); +x_122 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_122, 0, x_120); +lean_ctor_set(x_122, 1, x_121); +if (x_116 == 0) +{ +lean_object* x_123; lean_object* x_124; uint8_t x_125; lean_object* x_126; lean_object* x_127; +x_123 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +x_124 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_122); +x_125 = 0; +x_126 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_126, 0, x_124); +lean_ctor_set_uint8(x_126, sizeof(void*)*1, x_125); +x_127 = l_Repr_addAppParen(x_126, x_2); +return x_127; +} +else +{ +lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_128 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +x_129 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set(x_129, 1, x_122); +x_130 = 0; +x_131 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_131, 0, x_129); +lean_ctor_set_uint8(x_131, sizeof(void*)*1, x_130); +x_132 = l_Repr_addAppParen(x_131, x_2); +return x_132; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_133 = lean_ctor_get(x_1, 0); +x_134 = lean_ctor_get(x_1, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_1); +x_135 = lean_unsigned_to_nat(1024u); +x_136 = lean_nat_dec_le(x_135, x_2); +x_137 = l_Lean_Name_reprPrec(x_133, x_135); +x_138 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__14; +x_139 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_137); +x_140 = lean_box(1); +x_141 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_141, 0, x_139); +lean_ctor_set(x_141, 1, x_140); +x_142 = l_Lean_Name_reprPrec(x_134, x_135); +x_143 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_143, 0, x_141); +lean_ctor_set(x_143, 1, x_142); +if (x_136 == 0) +{ +lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; +x_144 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4; +x_145 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_145, 0, x_144); +lean_ctor_set(x_145, 1, x_143); +x_146 = 0; +x_147 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set_uint8(x_147, sizeof(void*)*1, x_146); +x_148 = l_Repr_addAppParen(x_147, x_2); +return x_148; +} +else +{ +lean_object* x_149; lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; +x_149 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5; +x_150 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_150, 0, x_149); +lean_ctor_set(x_150, 1, x_143); +x_151 = 0; +x_152 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set_uint8(x_152, sizeof(void*)*1, x_151); +x_153 = l_Repr_addAppParen(x_152, x_2); +return x_153; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92_(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instReprBuildKey___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instReprBuildKey() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instReprBuildKey___closed__1; +return x_1; +} +} +LEAN_EXPORT uint8_t l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(lean_object* x_1, lean_object* x_2) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = lean_ctor_get(x_1, 1); +x_5 = lean_ctor_get(x_2, 0); +x_6 = lean_ctor_get(x_2, 1); +x_7 = lean_name_eq(x_3, x_5); +if (x_7 == 0) +{ +uint8_t x_8; +x_8 = 0; +return x_8; +} +else +{ +uint8_t x_9; +x_9 = lean_name_eq(x_4, x_6); +return x_9; +} +} +else +{ +uint8_t x_10; +x_10 = 0; +return x_10; +} +} +case 1: +{ +if (lean_obj_tag(x_2) == 1) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_11 = lean_ctor_get(x_1, 0); +x_12 = lean_ctor_get(x_1, 1); +x_13 = lean_ctor_get(x_2, 0); +x_14 = lean_ctor_get(x_2, 1); +x_15 = lean_name_eq(x_11, x_13); +if (x_15 == 0) +{ +uint8_t x_16; +x_16 = 0; +return x_16; +} +else +{ +uint8_t x_17; +x_17 = lean_name_eq(x_12, x_14); +return x_17; +} +} +else +{ +uint8_t x_18; +x_18 = 0; +return x_18; +} +} +case 2: +{ +if (lean_obj_tag(x_2) == 2) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_19 = lean_ctor_get(x_1, 0); +x_20 = lean_ctor_get(x_1, 1); +x_21 = lean_ctor_get(x_1, 2); +x_22 = lean_ctor_get(x_2, 0); +x_23 = lean_ctor_get(x_2, 1); +x_24 = lean_ctor_get(x_2, 2); +x_25 = lean_name_eq(x_19, x_22); +if (x_25 == 0) +{ +uint8_t x_26; +x_26 = 0; +return x_26; +} +else +{ +uint8_t x_27; +x_27 = lean_name_eq(x_20, x_23); +if (x_27 == 0) +{ +uint8_t x_28; +x_28 = 0; +return x_28; +} +else +{ +uint8_t x_29; +x_29 = lean_name_eq(x_21, x_24); +return x_29; +} +} +} +else +{ +uint8_t x_30; +x_30 = 0; +return x_30; +} +} +default: +{ +if (lean_obj_tag(x_2) == 3) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; +x_31 = lean_ctor_get(x_1, 0); +x_32 = lean_ctor_get(x_1, 1); +x_33 = lean_ctor_get(x_2, 0); +x_34 = lean_ctor_get(x_2, 1); +x_35 = lean_name_eq(x_31, x_33); +if (x_35 == 0) +{ +uint8_t x_36; +x_36 = 0; +return x_36; +} +else +{ +uint8_t x_37; +x_37 = lean_name_eq(x_32, x_34); +return x_37; +} +} +else +{ +uint8_t x_38; +x_38 = 0; +return x_38; +} +} +} +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT uint8_t l_Lake_instDecidableEqBuildKey(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = l___private_Lake_Build_Key_0__Lake_decEqBuildKey____x40_Lake_Build_Key___hyg_325_(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instDecidableEqBuildKey___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lake_instDecidableEqBuildKey(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT uint64_t l___private_Lake_Build_Key_0__Lake_hashBuildKey____x40_Lake_Build_Key___hyg_1274_(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_2; lean_object* x_3; uint64_t x_4; uint64_t x_5; uint64_t x_6; uint64_t x_7; uint64_t x_8; +x_2 = lean_ctor_get(x_1, 0); +x_3 = lean_ctor_get(x_1, 1); +x_4 = 0; +x_5 = l_Lean_Name_hash___override(x_2); +x_6 = lean_uint64_mix_hash(x_4, x_5); +x_7 = l_Lean_Name_hash___override(x_3); +x_8 = lean_uint64_mix_hash(x_6, x_7); +return x_8; +} +case 1: +{ +lean_object* x_9; lean_object* x_10; uint64_t x_11; uint64_t x_12; uint64_t x_13; uint64_t x_14; uint64_t x_15; +x_9 = lean_ctor_get(x_1, 0); +x_10 = lean_ctor_get(x_1, 1); +x_11 = 1; +x_12 = l_Lean_Name_hash___override(x_9); +x_13 = lean_uint64_mix_hash(x_11, x_12); +x_14 = l_Lean_Name_hash___override(x_10); +x_15 = lean_uint64_mix_hash(x_13, x_14); +return x_15; +} +case 2: +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; uint64_t x_19; uint64_t x_20; uint64_t x_21; uint64_t x_22; uint64_t x_23; uint64_t x_24; uint64_t x_25; +x_16 = lean_ctor_get(x_1, 0); +x_17 = lean_ctor_get(x_1, 1); +x_18 = lean_ctor_get(x_1, 2); +x_19 = 2; +x_20 = l_Lean_Name_hash___override(x_16); +x_21 = lean_uint64_mix_hash(x_19, x_20); +x_22 = l_Lean_Name_hash___override(x_17); +x_23 = lean_uint64_mix_hash(x_21, x_22); +x_24 = l_Lean_Name_hash___override(x_18); +x_25 = lean_uint64_mix_hash(x_23, x_24); +return x_25; +} +default: +{ +lean_object* x_26; lean_object* x_27; uint64_t x_28; uint64_t x_29; uint64_t x_30; uint64_t x_31; uint64_t x_32; +x_26 = lean_ctor_get(x_1, 0); +x_27 = lean_ctor_get(x_1, 1); +x_28 = 3; +x_29 = l_Lean_Name_hash___override(x_26); +x_30 = lean_uint64_mix_hash(x_28, x_29); +x_31 = l_Lean_Name_hash___override(x_27); +x_32 = lean_uint64_mix_hash(x_30, x_31); +return x_32; +} +} +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_hashBuildKey____x40_Lake_Build_Key___hyg_1274____boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = l___private_Lake_Build_Key_0__Lake_hashBuildKey____x40_Lake_Build_Key___hyg_1274_(x_1); +lean_dec(x_1); +x_3 = lean_box_uint64(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instHashableBuildKey___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Key_0__Lake_hashBuildKey____x40_Lake_Build_Key___hyg_1274____boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instHashableBuildKey() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instHashableBuildKey___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_BuildKey_toString___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("+", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildKey_toString___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildKey_toString___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildKey_toString___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("@", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildKey_toString___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("/", 1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildKey_toString(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = lean_ctor_get(x_1, 1); +lean_inc(x_3); +lean_dec(x_1); +x_4 = 1; +x_5 = l_Lean_Name_toString(x_2, x_4); +x_6 = l_Lake_BuildKey_toString___closed__1; +x_7 = lean_string_append(x_6, x_5); +lean_dec(x_5); +x_8 = l_Lake_BuildKey_toString___closed__2; +x_9 = lean_string_append(x_7, x_8); +x_10 = l_Lean_Name_toString(x_3, x_4); +x_11 = lean_string_append(x_9, x_10); +lean_dec(x_10); +x_12 = l_Lake_BuildKey_toString___closed__3; +x_13 = lean_string_append(x_11, x_12); +return x_13; +} +case 1: +{ +lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_14 = lean_ctor_get(x_1, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_1, 1); +lean_inc(x_15); +lean_dec(x_1); +x_16 = 1; +x_17 = l_Lean_Name_toString(x_14, x_16); +x_18 = l_Lake_BuildKey_toString___closed__4; +x_19 = lean_string_append(x_18, x_17); +lean_dec(x_17); +x_20 = l_Lake_BuildKey_toString___closed__2; +x_21 = lean_string_append(x_19, x_20); +x_22 = l_Lean_Name_toString(x_15, x_16); +x_23 = lean_string_append(x_21, x_22); +lean_dec(x_22); +x_24 = l_Lake_BuildKey_toString___closed__3; +x_25 = lean_string_append(x_23, x_24); +return x_25; +} +case 2: +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_26 = lean_ctor_get(x_1, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_1, 1); +lean_inc(x_27); +x_28 = lean_ctor_get(x_1, 2); +lean_inc(x_28); +lean_dec(x_1); +x_29 = 1; +x_30 = l_Lean_Name_toString(x_26, x_29); +x_31 = l_Lake_BuildKey_toString___closed__3; +x_32 = lean_string_append(x_31, x_30); +lean_dec(x_30); +x_33 = l_Lake_BuildKey_toString___closed__5; +x_34 = lean_string_append(x_32, x_33); +x_35 = l_Lean_Name_toString(x_27, x_29); +x_36 = lean_string_append(x_34, x_35); +lean_dec(x_35); +x_37 = l_Lake_BuildKey_toString___closed__2; +x_38 = lean_string_append(x_36, x_37); +x_39 = l_Lean_Name_toString(x_28, x_29); +x_40 = lean_string_append(x_38, x_39); +lean_dec(x_39); +x_41 = lean_string_append(x_40, x_31); +return x_41; +} +default: +{ +lean_object* x_42; lean_object* x_43; uint8_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_42 = lean_ctor_get(x_1, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_1, 1); +lean_inc(x_43); +lean_dec(x_1); +x_44 = 1; +x_45 = l_Lean_Name_toString(x_42, x_44); +x_46 = l_Lake_BuildKey_toString___closed__3; +x_47 = lean_string_append(x_46, x_45); +lean_dec(x_45); +x_48 = l_Lake_BuildKey_toString___closed__5; +x_49 = lean_string_append(x_47, x_48); +x_50 = l_Lean_Name_toString(x_43, x_44); +x_51 = lean_string_append(x_49, x_50); +lean_dec(x_50); +x_52 = lean_string_append(x_51, x_46); +return x_52; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildKey_toSimpleString_eraseHead(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_2; +x_2 = lean_box(0); +return x_2; +} +case 1: +{ +lean_object* x_3; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_4; +lean_dec(x_1); +x_4 = lean_box(0); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = l_Lake_BuildKey_toSimpleString_eraseHead(x_3); +x_7 = l_Lean_Name_str___override(x_6, x_5); +return x_7; +} +} +default: +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; +lean_dec(x_1); +x_9 = lean_box(0); +return x_9; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_1, 1); +lean_inc(x_10); +lean_dec(x_1); +x_11 = l_Lake_BuildKey_toSimpleString_eraseHead(x_8); +x_12 = l_Lean_Name_num___override(x_11, x_10); +return x_12; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildKey_toSimpleString(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 2: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; uint8_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_2 = lean_ctor_get(x_1, 0); +lean_inc(x_2); +x_3 = lean_ctor_get(x_1, 1); +lean_inc(x_3); +x_4 = lean_ctor_get(x_1, 2); +lean_inc(x_4); +lean_dec(x_1); +x_5 = 1; +x_6 = l_Lean_Name_toString(x_2, x_5); +x_7 = l_Lake_BuildKey_toString___closed__3; +x_8 = lean_string_append(x_7, x_6); +lean_dec(x_6); +x_9 = l_Lake_BuildKey_toString___closed__5; +x_10 = lean_string_append(x_8, x_9); +x_11 = l_Lean_Name_toString(x_3, x_5); +x_12 = lean_string_append(x_10, x_11); +lean_dec(x_11); +x_13 = l_Lake_BuildKey_toString___closed__2; +x_14 = lean_string_append(x_12, x_13); +x_15 = l_Lake_BuildKey_toSimpleString_eraseHead(x_4); +x_16 = l_Lean_Name_toString(x_15, x_5); +x_17 = lean_string_append(x_14, x_16); +lean_dec(x_16); +x_18 = lean_string_append(x_17, x_7); +return x_18; +} +case 3: +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_19 = lean_ctor_get(x_1, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_1, 1); +lean_inc(x_20); +lean_dec(x_1); +x_21 = 1; +x_22 = l_Lean_Name_toString(x_19, x_21); +x_23 = l_Lake_BuildKey_toString___closed__3; +x_24 = lean_string_append(x_23, x_22); +lean_dec(x_22); +x_25 = l_Lake_BuildKey_toString___closed__5; +x_26 = lean_string_append(x_24, x_25); +x_27 = l_Lean_Name_toString(x_20, x_21); +x_28 = lean_string_append(x_26, x_27); +lean_dec(x_27); +x_29 = lean_string_append(x_28, x_23); +return x_29; +} +default: +{ +lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_30 = lean_ctor_get(x_1, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_1, 1); +lean_inc(x_31); +lean_dec(x_1); +x_32 = 1; +x_33 = l_Lean_Name_toString(x_30, x_32); +x_34 = l_Lake_BuildKey_toString___closed__3; +x_35 = lean_string_append(x_34, x_33); +lean_dec(x_33); +x_36 = l_Lake_BuildKey_toString___closed__2; +x_37 = lean_string_append(x_35, x_36); +x_38 = l_Lean_Name_toString(x_31, x_32); +x_39 = lean_string_append(x_37, x_38); +lean_dec(x_38); +x_40 = lean_string_append(x_39, x_34); +return x_40; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildKey_instToString(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_BuildKey_toString(x_1); +return x_2; +} +} +LEAN_EXPORT uint8_t l_Lake_BuildKey_quickCmp(lean_object* x_1, lean_object* x_2) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; lean_object* x_8; +x_3 = lean_ctor_get(x_1, 0); +x_4 = lean_ctor_get(x_1, 1); +x_5 = lean_ctor_get(x_2, 0); +x_6 = lean_ctor_get(x_2, 1); +x_7 = l_Lean_Name_quickCmp(x_3, x_5); +x_8 = lean_box(x_7); +if (lean_obj_tag(x_8) == 1) +{ +uint8_t x_9; +x_9 = l_Lean_Name_quickCmp(x_4, x_6); +return x_9; +} +else +{ +lean_dec(x_8); +return x_7; +} +} +else +{ +uint8_t x_10; +x_10 = 0; +return x_10; +} +} +case 1: +{ +switch (lean_obj_tag(x_2)) { +case 0: +{ +uint8_t x_11; +x_11 = 2; +return x_11; +} +case 1: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; +x_12 = lean_ctor_get(x_1, 0); +x_13 = lean_ctor_get(x_1, 1); +x_14 = lean_ctor_get(x_2, 0); +x_15 = lean_ctor_get(x_2, 1); +x_16 = l_Lean_Name_quickCmp(x_12, x_14); +x_17 = lean_box(x_16); +if (lean_obj_tag(x_17) == 1) +{ +uint8_t x_18; +x_18 = l_Lean_Name_quickCmp(x_13, x_15); +return x_18; +} +else +{ +lean_dec(x_17); +return x_16; +} +} +default: +{ +uint8_t x_19; +x_19 = 0; +return x_19; +} +} +} +case 2: +{ +switch (lean_obj_tag(x_2)) { +case 2: +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; +x_20 = lean_ctor_get(x_1, 0); +x_21 = lean_ctor_get(x_1, 1); +x_22 = lean_ctor_get(x_1, 2); +x_23 = lean_ctor_get(x_2, 0); +x_24 = lean_ctor_get(x_2, 1); +x_25 = lean_ctor_get(x_2, 2); +x_26 = l_Lean_Name_quickCmp(x_20, x_23); +x_27 = lean_box(x_26); +if (lean_obj_tag(x_27) == 1) +{ +uint8_t x_28; lean_object* x_29; +x_28 = l_Lean_Name_quickCmp(x_21, x_24); +x_29 = lean_box(x_28); +if (lean_obj_tag(x_29) == 1) +{ +uint8_t x_30; +x_30 = l_Lean_Name_quickCmp(x_22, x_25); +return x_30; +} +else +{ +lean_dec(x_29); +return x_28; +} +} +else +{ +lean_dec(x_27); +return x_26; +} +} +case 3: +{ +uint8_t x_31; +x_31 = 0; +return x_31; +} +default: +{ +uint8_t x_32; +x_32 = 2; +return x_32; +} +} +} +default: +{ +if (lean_obj_tag(x_2) == 3) +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; +x_33 = lean_ctor_get(x_1, 0); +x_34 = lean_ctor_get(x_1, 1); +x_35 = lean_ctor_get(x_2, 0); +x_36 = lean_ctor_get(x_2, 1); +x_37 = l_Lean_Name_quickCmp(x_33, x_35); +x_38 = lean_box(x_37); +if (lean_obj_tag(x_38) == 1) +{ +uint8_t x_39; +x_39 = l_Lean_Name_quickCmp(x_34, x_36); +return x_39; +} +else +{ +lean_dec(x_38); +return x_37; +} +} +else +{ +uint8_t x_40; +x_40 = 2; +return x_40; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildKey_quickCmp___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lake_BuildKey_quickCmp(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_box(x_1); +if (lean_obj_tag(x_4) == 1) +{ +lean_dec(x_3); +lean_inc(x_2); +return x_2; +} +else +{ +lean_object* x_5; lean_object* x_6; +lean_dec(x_4); +x_5 = lean_box(x_1); +x_6 = lean_apply_2(x_3, x_5, lean_box(0)); +return x_6; +} +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; lean_object* x_5; +x_4 = lean_unbox(x_1); +lean_dec(x_1); +x_5 = l___private_Lake_Build_Key_0__Lake_BuildKey_quickCmp_match__1_splitter___rarg(x_4, x_2, x_3); +lean_dec(x_2); +return x_5; +} +} +static lean_object* _init_l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildKey_quickCmp___boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildKey_instLawfulCmpEqQuickCmp() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__2; +return x_1; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Name(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Key(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Name(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_instInhabitedBuildKey___closed__1 = _init_l_Lake_instInhabitedBuildKey___closed__1(); +lean_mark_persistent(l_Lake_instInhabitedBuildKey___closed__1); +l_Lake_instInhabitedBuildKey = _init_l_Lake_instInhabitedBuildKey(); +lean_mark_persistent(l_Lake_instInhabitedBuildKey); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__1 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__1(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__1); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__2 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__2(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__2); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__3 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__3(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__3); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__4); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__5); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__6 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__6(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__6); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__7 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__7(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__7); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__8 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__8(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__8); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__9 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__9(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__9); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__10 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__10(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__10); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__11 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__11(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__11); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__12 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__12(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__12); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__13 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__13(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__13); +l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__14 = _init_l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__14(); +lean_mark_persistent(l___private_Lake_Build_Key_0__Lake_reprBuildKey____x40_Lake_Build_Key___hyg_92____closed__14); +l_Lake_instReprBuildKey___closed__1 = _init_l_Lake_instReprBuildKey___closed__1(); +lean_mark_persistent(l_Lake_instReprBuildKey___closed__1); +l_Lake_instReprBuildKey = _init_l_Lake_instReprBuildKey(); +lean_mark_persistent(l_Lake_instReprBuildKey); +l_Lake_instHashableBuildKey___closed__1 = _init_l_Lake_instHashableBuildKey___closed__1(); +lean_mark_persistent(l_Lake_instHashableBuildKey___closed__1); +l_Lake_instHashableBuildKey = _init_l_Lake_instHashableBuildKey(); +lean_mark_persistent(l_Lake_instHashableBuildKey); +l_Lake_BuildKey_toString___closed__1 = _init_l_Lake_BuildKey_toString___closed__1(); +lean_mark_persistent(l_Lake_BuildKey_toString___closed__1); +l_Lake_BuildKey_toString___closed__2 = _init_l_Lake_BuildKey_toString___closed__2(); +lean_mark_persistent(l_Lake_BuildKey_toString___closed__2); +l_Lake_BuildKey_toString___closed__3 = _init_l_Lake_BuildKey_toString___closed__3(); +lean_mark_persistent(l_Lake_BuildKey_toString___closed__3); +l_Lake_BuildKey_toString___closed__4 = _init_l_Lake_BuildKey_toString___closed__4(); +lean_mark_persistent(l_Lake_BuildKey_toString___closed__4); +l_Lake_BuildKey_toString___closed__5 = _init_l_Lake_BuildKey_toString___closed__5(); +lean_mark_persistent(l_Lake_BuildKey_toString___closed__5); +l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__1 = _init_l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__1(); +lean_mark_persistent(l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__1); +l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__2 = _init_l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__2(); +lean_mark_persistent(l_Lake_BuildKey_instLawfulCmpEqQuickCmp___closed__2); +l_Lake_BuildKey_instLawfulCmpEqQuickCmp = _init_l_Lake_BuildKey_instLawfulCmpEqQuickCmp(); +lean_mark_persistent(l_Lake_BuildKey_instLawfulCmpEqQuickCmp); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Library.c b/stage0/stdlib/Lake/Build/Library.c new file mode 100644 index 0000000000..6d08a19ee8 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Library.c @@ -0,0 +1,8977 @@ +// Lean compiler output +// Module: Lake.Build.Library +// Imports: Init Lake.Build.Common Lake.Build.Targets +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* l_Lake_Package_fetchTargetJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_modulesFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_LeanLib_recCollectLocalModules_go___spec__1___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2___boxed(lean_object*, lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +static lean_object* l_Lake_LeanLib_sharedFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_modulesFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules___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_EXPORT lean_object* l_Lake_LeanLib_staticFacetConfig; +lean_object* l_System_FilePath_join(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_staticFacetConfig___closed__6; +lean_object* l_Lake_nameToSharedLib(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_sharedFacetConfig; +static lean_object* l_Lake_LeanLib_staticExportFacetConfig___closed__1; +static lean_object* l_Lake_LeanLib_sharedFacetConfig___closed__2; +static lean_object* l_Lake_LeanLib_staticFacetConfig___closed__2; +static lean_object* l_Lake_LeanLib_recCollectLocalModules___closed__3; +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildShared(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__1; +size_t lean_hashset_mk_idx(lean_object*, uint64_t); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_LeanLib_recCollectLocalModules_go___spec__5(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recBuildShared___spec__7(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanLib_recBuildShared___spec__16___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_LeanLib_recBuildShared___spec__2___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanLib_recBuildShared___spec__16(lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +lean_object* l_Lean_mkHashSetImp___rarg(lean_object*); +lean_object* l_Lake_LeanLib_getModuleArray(lean_object*, lean_object*); +lean_object* lean_mk_array(lean_object*, lean_object*); +uint8_t lean_usize_dec_eq(size_t, size_t); +static lean_object* l_Lake_LeanLib_recCollectLocalModules_go___closed__4; +static lean_object* l_Lake_initLibraryFacetConfigs___closed__2; +lean_object* lean_array_fget(lean_object*, lean_object*); +lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_staticFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_LeanLib_staticFacetConfig___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__2(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__14___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_extraDepFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildExtraDepTargets(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__15(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__2; +extern lean_object* l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +static lean_object* l_Lake_LeanLib_staticExportFacetConfig___closed__3; +lean_object* l_Lake_buildStaticLib(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildShared___closed__1; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_LeanLib_recCollectLocalModules_go___spec__3(lean_object*, lean_object*); +lean_object* l_Lake_buildLeanSharedLib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +size_t lean_usize_of_nat(lean_object*); +static lean_object* l_Lake_LeanLib_recBuildStatic___closed__6; +lean_object* lean_task_pure(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_modulesFacetConfig; +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recCollectLocalModules_go___spec__6(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initLibraryFacetConfigs___closed__5; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__13(lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_withRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_LeanLib_recCollectLocalModules_go___spec__1(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildLean___closed__5; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules_go___spec__9(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_initLibraryFacetConfigs; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__11(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildLean(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildExtraDepTargets___closed__2; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__14(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__11___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticExportFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_leanArtsFacetConfig___closed__4; +LEAN_EXPORT uint8_t l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2(lean_object*, lean_object*); +uint8_t l_Lake_LeanLibConfig_isLocalModule(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_System_FilePath_addExtension(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recBuildShared___spec__7___at_Lake_LeanLib_recBuildShared___spec__8(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Task_Priority_default; +static lean_object* l_Lake_LeanLib_recBuildStatic___closed__4; +static lean_object* l_Lake_initLibraryFacetConfigs___closed__6; +LEAN_EXPORT uint8_t l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_name_eq(lean_object*, lean_object*); +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_LeanLib_recBuildShared___spec__5(lean_object*, lean_object*); +lean_object* l_Lake_EquipT_instMonad___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_leanArtsFacetConfig; +static lean_object* l_Lake_LeanLib_recCollectLocalModules___closed__1; +extern lean_object* l_instMonadBaseIO; +lean_object* l_Lake_BuildJob_mix___rarg(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_LeanLib_recBuildShared___spec__2(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_staticFacetConfig___closed__4; +extern lean_object* l_Lake_BuildTrace_nil; +static lean_object* l_Lake_LeanLib_recBuildStatic___closed__5; +static lean_object* l_Lake_LeanLib_recCollectLocalModules_go___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recCollectLocalModules___closed__2; +lean_object* l_Lake_EResult_map___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_modulesFacetConfig___closed__3; +static lean_object* l_Lake_LeanLib_recBuildLean___closed__2; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_LeanLib_recBuildShared___spec__6(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_leanArtsFacetConfig___closed__2; +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_staticExportFacetConfig___closed__2; +static lean_object* l_Lake_LeanLib_leanArtsFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__3(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_modulesFacetConfig___closed__4; +static lean_object* l_Lake_LeanLib_recCollectLocalModules_go___closed__1; +uint8_t l_Lake_instDecidableEqVerbosity(uint8_t, uint8_t); +lean_object* l_StateT_instMonad___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__15___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___lambda__1(lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules_go___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildLean___closed__3; +static lean_object* l_Lake_initLibraryFacetConfigs___closed__1; +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanLib_recBuildShared___spec__10(lean_object*, lean_object*, lean_object*); +lean_object* l_Array_mapMUnsafe_map___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildExtraDepTargets___closed__1; +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +lean_object* l_Lake_EquipT_bind___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__1; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__12___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_LeanLib_recCollectLocalModules_go___spec__4(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_extraDepFacetConfig___closed__1; +uint64_t l_Lean_Name_hash___override(lean_object*); +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildStatic___closed__2; +lean_object* l_Lake_instHashablePackage___boxed(lean_object*); +static lean_object* l_Lake_LeanLib_recBuildStatic___closed__3; +lean_object* lean_task_map(lean_object*, lean_object*, lean_object*, uint8_t); +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__1; +lean_object* lean_nat_mul(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildShared___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1(lean_object*); +static lean_object* l_Lake_LeanLib_sharedFacetConfig___closed__1; +static lean_object* l_Lake_initLibraryFacetConfigs___closed__4; +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildShared___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticExportFacetConfig; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_LeanLib_recBuildShared___spec__4(lean_object*, lean_object*); +lean_object* l_Lake_nameToStaticLib(lean_object*); +static lean_object* l_Lake_initLibraryFacetConfigs___closed__3; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___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*); +size_t lean_usize_add(size_t, size_t); +static lean_object* l_Lake_LeanLib_recBuildStatic___closed__1; +static lean_object* l_Lake_LeanLib_staticFacetConfig___closed__5; +lean_object* l_Lean_RBNode_insert___at_Lake_Workspace_addLibraryFacetConfig___spec__1(lean_object*, lean_object*, lean_object*); +lean_object* lean_array_uget(lean_object*, size_t); +lean_object* l_Array_foldlMUnsafe_fold___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*); +lean_object* lean_io_error_to_string(lean_object*); +static lean_object* l_Lake_LeanLib_recBuildStatic___closed__7; +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_sharedFacetConfig___closed__4; +lean_object* l_Lake_instBEqPackage___boxed(lean_object*, lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildLean___closed__4; +static lean_object* l_Lake_LeanLib_leanArtsFacetConfig___closed__3; +lean_object* lean_array_get_size(lean_object*); +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recCollectLocalModules_go___spec__6___at_Lake_LeanLib_recCollectLocalModules_go___spec__7(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__2; +static lean_object* l_Lake_LeanLib_staticFacetConfig___closed__3; +lean_object* l_Lake_EStateT_instMonad___rarg(lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +uint8_t lean_usize_dec_lt(size_t, size_t); +LEAN_EXPORT lean_object* l_Lake_LeanLib_extraDepFacetConfig; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___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* lean_nat_add(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recCollectLocalModules_go___closed__3; +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanLib_recBuildShared___spec__10___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildLean___closed__1; +lean_object* lean_array_uset(lean_object*, size_t, lean_object*); +static lean_object* l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1; +lean_object* l_ReaderT_instMonad___rarg(lean_object*); +static lean_object* l_Lake_LeanLib_recBuildLean___closed__6; +static lean_object* l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2; +LEAN_EXPORT uint8_t l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_4, 2); +x_7 = lean_ctor_get(x_1, 2); +x_8 = lean_name_eq(x_6, x_7); +if (x_8 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_10; +x_10 = 1; +return x_10; +} +} +} +} +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_LeanLib_recCollectLocalModules_go___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint64_t x_6; size_t x_7; lean_object* x_8; uint8_t x_9; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = lean_ctor_get(x_2, 2); +x_6 = l_Lean_Name_hash___override(x_5); +x_7 = lean_hashset_mk_idx(x_4, x_6); +x_8 = lean_array_uget(x_3, x_7); +x_9 = l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2(x_2, x_8); +lean_dec(x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recCollectLocalModules_go___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_3, 1); +x_7 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_5); +x_8 = lean_apply_1(x_1, x_5); +x_9 = lean_unbox_uint64(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_7, x_9); +x_11 = lean_array_uget(x_2, x_10); +lean_ctor_set(x_3, 1, x_11); +x_12 = lean_array_uset(x_2, x_10, x_3); +x_2 = x_12; +x_3 = x_6; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint64_t x_18; size_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_14 = lean_ctor_get(x_3, 0); +x_15 = lean_ctor_get(x_3, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_3); +x_16 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_14); +x_17 = lean_apply_1(x_1, x_14); +x_18 = lean_unbox_uint64(x_17); +lean_dec(x_17); +x_19 = lean_hashset_mk_idx(x_16, x_18); +x_20 = lean_array_uget(x_2, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_14); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_array_uset(x_2, x_19, x_21); +x_2 = x_22; +x_3 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recCollectLocalModules_go___spec__6___at_Lake_LeanLib_recCollectLocalModules_go___spec__7(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint64_t x_8; size_t x_9; lean_object* x_10; lean_object* x_11; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_array_get_size(x_1); +x_7 = lean_ctor_get(x_4, 2); +lean_inc(x_7); +x_8 = l_Lean_Name_hash___override(x_7); +lean_dec(x_7); +x_9 = lean_hashset_mk_idx(x_6, x_8); +x_10 = lean_array_uget(x_1, x_9); +lean_ctor_set(x_2, 1, x_10); +x_11 = lean_array_uset(x_1, x_9, x_2); +x_1 = x_11; +x_2 = x_5; +goto _start; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint64_t x_17; size_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_13 = lean_ctor_get(x_2, 0); +x_14 = lean_ctor_get(x_2, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_2); +x_15 = lean_array_get_size(x_1); +x_16 = lean_ctor_get(x_13, 2); +lean_inc(x_16); +x_17 = l_Lean_Name_hash___override(x_16); +lean_dec(x_16); +x_18 = lean_hashset_mk_idx(x_15, x_17); +x_19 = lean_array_uget(x_1, x_18); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_13); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_array_uset(x_1, x_18, x_20); +x_1 = x_21; +x_2 = x_14; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_LeanLib_recCollectLocalModules_go___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_array_get_size(x_2); +x_5 = lean_nat_dec_lt(x_1, x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_6 = lean_array_fget(x_2, x_1); +x_7 = lean_box(0); +x_8 = lean_array_fset(x_2, x_1, x_7); +x_9 = l_List_foldl___at_Lake_LeanLib_recCollectLocalModules_go___spec__6___at_Lake_LeanLib_recCollectLocalModules_go___spec__7(x_3, x_6); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_8; +x_3 = x_9; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_LeanLib_recCollectLocalModules_go___spec__4(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_nat_mul(x_3, x_4); +lean_dec(x_3); +x_6 = lean_box(0); +x_7 = lean_mk_array(x_5, x_6); +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_HashSetImp_moveEntries___at_Lake_LeanLib_recCollectLocalModules_go___spec__5(x_8, x_2, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; +lean_dec(x_3); +x_4 = lean_box(0); +return x_4; +} +else +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_1); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_6 = lean_ctor_get(x_1, 0); +x_7 = lean_ctor_get(x_1, 1); +x_8 = lean_ctor_get(x_6, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_2, 2); +x_10 = lean_name_eq(x_8, x_9); +lean_dec(x_8); +if (x_10 == 0) +{ +lean_object* x_11; +x_11 = l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8(x_7, x_2, x_3); +lean_ctor_set(x_1, 1, x_11); +return x_1; +} +else +{ +lean_dec(x_6); +lean_ctor_set(x_1, 0, x_3); +return x_1; +} +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_12 = lean_ctor_get(x_1, 0); +x_13 = lean_ctor_get(x_1, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_1); +x_14 = lean_ctor_get(x_12, 2); +lean_inc(x_14); +x_15 = lean_ctor_get(x_2, 2); +x_16 = lean_name_eq(x_14, x_15); +lean_dec(x_14); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8(x_13, x_2, x_3); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_12); +lean_ctor_set(x_18, 1, x_17); +return x_18; +} +else +{ +lean_object* x_19; +lean_dec(x_12); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_3); +lean_ctor_set(x_19, 1, x_13); +return x_19; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_LeanLib_recCollectLocalModules_go___spec__3(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_1); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint64_t x_8; size_t x_9; lean_object* x_10; uint8_t x_11; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_array_get_size(x_5); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = l_Lean_Name_hash___override(x_7); +lean_dec(x_7); +lean_inc(x_6); +x_9 = lean_hashset_mk_idx(x_6, x_8); +x_10 = lean_array_uget(x_5, x_9); +x_11 = l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2(x_2, x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_12 = lean_unsigned_to_nat(1u); +x_13 = lean_nat_add(x_4, x_12); +lean_dec(x_4); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_2); +lean_ctor_set(x_14, 1, x_10); +x_15 = lean_array_uset(x_5, x_9, x_14); +x_16 = lean_nat_dec_le(x_13, x_6); +lean_dec(x_6); +if (x_16 == 0) +{ +lean_object* x_17; +lean_free_object(x_1); +x_17 = l_Lean_HashSetImp_expand___at_Lake_LeanLib_recCollectLocalModules_go___spec__4(x_13, x_15); +return x_17; +} +else +{ +lean_ctor_set(x_1, 1, x_15); +lean_ctor_set(x_1, 0, x_13); +return x_1; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +lean_dec(x_6); +x_18 = lean_box(0); +x_19 = lean_array_uset(x_5, x_9, x_18); +lean_inc(x_2); +x_20 = l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8(x_10, x_2, x_2); +lean_dec(x_2); +x_21 = lean_array_uset(x_19, x_9, x_20); +lean_ctor_set(x_1, 1, x_21); +return x_1; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint64_t x_26; size_t x_27; lean_object* x_28; uint8_t x_29; +x_22 = lean_ctor_get(x_1, 0); +x_23 = lean_ctor_get(x_1, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_1); +x_24 = lean_array_get_size(x_23); +x_25 = lean_ctor_get(x_2, 2); +lean_inc(x_25); +x_26 = l_Lean_Name_hash___override(x_25); +lean_dec(x_25); +lean_inc(x_24); +x_27 = lean_hashset_mk_idx(x_24, x_26); +x_28 = lean_array_uget(x_23, x_27); +x_29 = l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2(x_2, x_28); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; +x_30 = lean_unsigned_to_nat(1u); +x_31 = lean_nat_add(x_22, x_30); +lean_dec(x_22); +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_2); +lean_ctor_set(x_32, 1, x_28); +x_33 = lean_array_uset(x_23, x_27, x_32); +x_34 = lean_nat_dec_le(x_31, x_24); +lean_dec(x_24); +if (x_34 == 0) +{ +lean_object* x_35; +x_35 = l_Lean_HashSetImp_expand___at_Lake_LeanLib_recCollectLocalModules_go___spec__4(x_31, x_33); +return x_35; +} +else +{ +lean_object* x_36; +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_31); +lean_ctor_set(x_36, 1, x_33); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_dec(x_24); +x_37 = lean_box(0); +x_38 = lean_array_uset(x_23, x_27, x_37); +lean_inc(x_2); +x_39 = l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8(x_28, x_2, x_2); +lean_dec(x_2); +x_40 = lean_array_uset(x_38, x_27, x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_22); +lean_ctor_set(x_41, 1, x_40); +return x_41; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules_go___spec__9(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; uint8_t x_55; +x_55 = lean_usize_dec_lt(x_4, x_3); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_5); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_11); +return x_58; +} +else +{ +lean_object* x_59; uint8_t x_60; +x_59 = lean_array_uget(x_2, x_4); +x_60 = !lean_is_exclusive(x_5); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; +x_61 = lean_ctor_get(x_5, 0); +x_62 = lean_ctor_get(x_5, 1); +x_63 = lean_ctor_get(x_59, 1); +lean_inc(x_63); +x_64 = lean_ctor_get(x_1, 1); +x_65 = l_Lake_LeanLibConfig_isLocalModule(x_63, x_64); +lean_dec(x_63); +if (x_65 == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +lean_dec(x_59); +x_66 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_66, 0, x_5); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_9); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_67); +lean_ctor_set(x_68, 1, x_10); +x_12 = x_68; +x_13 = x_11; +goto block_54; +} +else +{ +lean_object* x_69; +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_69 = l_Lake_LeanLib_recCollectLocalModules_go(x_1, x_59, x_62, x_61, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_69) == 0) +{ +lean_object* x_70; lean_object* x_71; +x_70 = lean_ctor_get(x_69, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_70, 0); +lean_inc(x_71); +if (lean_obj_tag(x_71) == 0) +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; +x_72 = lean_ctor_get(x_71, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_69, 1); +lean_inc(x_73); +lean_dec(x_69); +x_74 = lean_ctor_get(x_70, 1); +lean_inc(x_74); +lean_dec(x_70); +x_75 = !lean_is_exclusive(x_71); +if (x_75 == 0) +{ +lean_object* x_76; uint8_t x_77; +x_76 = lean_ctor_get(x_71, 0); +lean_dec(x_76); +x_77 = !lean_is_exclusive(x_72); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_78 = lean_ctor_get(x_72, 0); +x_79 = lean_ctor_get(x_72, 1); +lean_ctor_set(x_5, 1, x_78); +lean_ctor_set(x_5, 0, x_79); +x_80 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_80, 0, x_5); +lean_ctor_set(x_71, 0, x_80); +lean_ctor_set(x_72, 1, x_74); +lean_ctor_set(x_72, 0, x_71); +x_12 = x_72; +x_13 = x_73; +goto block_54; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_81 = lean_ctor_get(x_72, 0); +x_82 = lean_ctor_get(x_72, 1); +lean_inc(x_82); +lean_inc(x_81); +lean_dec(x_72); +lean_ctor_set(x_5, 1, x_81); +lean_ctor_set(x_5, 0, x_82); +x_83 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_83, 0, x_5); +lean_ctor_set(x_71, 0, x_83); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_71); +lean_ctor_set(x_84, 1, x_74); +x_12 = x_84; +x_13 = x_73; +goto block_54; +} +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_85 = lean_ctor_get(x_71, 1); +lean_inc(x_85); +lean_dec(x_71); +x_86 = lean_ctor_get(x_72, 0); +lean_inc(x_86); +x_87 = lean_ctor_get(x_72, 1); +lean_inc(x_87); +if (lean_is_exclusive(x_72)) { + lean_ctor_release(x_72, 0); + lean_ctor_release(x_72, 1); + x_88 = x_72; +} else { + lean_dec_ref(x_72); + x_88 = lean_box(0); +} +lean_ctor_set(x_5, 1, x_86); +lean_ctor_set(x_5, 0, x_87); +x_89 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_89, 0, x_5); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_85); +if (lean_is_scalar(x_88)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_88; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_74); +x_12 = x_91; +x_13 = x_73; +goto block_54; +} +} +else +{ +lean_object* x_92; uint8_t x_93; +lean_free_object(x_5); +x_92 = lean_ctor_get(x_69, 1); +lean_inc(x_92); +lean_dec(x_69); +x_93 = !lean_is_exclusive(x_70); +if (x_93 == 0) +{ +lean_object* x_94; uint8_t x_95; +x_94 = lean_ctor_get(x_70, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_71); +if (x_95 == 0) +{ +x_12 = x_70; +x_13 = x_92; +goto block_54; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_71, 0); +x_97 = lean_ctor_get(x_71, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_71); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +lean_ctor_set(x_70, 0, x_98); +x_12 = x_70; +x_13 = x_92; +goto block_54; +} +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_99 = lean_ctor_get(x_70, 1); +lean_inc(x_99); +lean_dec(x_70); +x_100 = lean_ctor_get(x_71, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_71, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_71)) { + lean_ctor_release(x_71, 0); + lean_ctor_release(x_71, 1); + x_102 = x_71; +} else { + lean_dec_ref(x_71); + x_102 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_103 = lean_alloc_ctor(1, 2, 0); +} else { + x_103 = x_102; +} +lean_ctor_set(x_103, 0, x_100); +lean_ctor_set(x_103, 1, x_101); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_99); +x_12 = x_104; +x_13 = x_92; +goto block_54; +} +} +} +else +{ +uint8_t x_105; +lean_free_object(x_5); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_105 = !lean_is_exclusive(x_69); +if (x_105 == 0) +{ +return x_69; +} +else +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; +x_106 = lean_ctor_get(x_69, 0); +x_107 = lean_ctor_get(x_69, 1); +lean_inc(x_107); +lean_inc(x_106); +lean_dec(x_69); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_106); +lean_ctor_set(x_108, 1, x_107); +return x_108; +} +} +} +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; +x_109 = lean_ctor_get(x_5, 0); +x_110 = lean_ctor_get(x_5, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_5); +x_111 = lean_ctor_get(x_59, 1); +lean_inc(x_111); +x_112 = lean_ctor_get(x_1, 1); +x_113 = l_Lake_LeanLibConfig_isLocalModule(x_111, x_112); +lean_dec(x_111); +if (x_113 == 0) +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +lean_dec(x_59); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_109); +lean_ctor_set(x_114, 1, x_110); +x_115 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_115, 0, x_114); +x_116 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_116, 0, x_115); +lean_ctor_set(x_116, 1, x_9); +x_117 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_117, 0, x_116); +lean_ctor_set(x_117, 1, x_10); +x_12 = x_117; +x_13 = x_11; +goto block_54; +} +else +{ +lean_object* x_118; +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_118 = l_Lake_LeanLib_recCollectLocalModules_go(x_1, x_59, x_110, x_109, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_118) == 0) +{ +lean_object* x_119; lean_object* x_120; +x_119 = lean_ctor_get(x_118, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +if (lean_obj_tag(x_120) == 0) +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_121 = lean_ctor_get(x_120, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_118, 1); +lean_inc(x_122); +lean_dec(x_118); +x_123 = lean_ctor_get(x_119, 1); +lean_inc(x_123); +lean_dec(x_119); +x_124 = lean_ctor_get(x_120, 1); +lean_inc(x_124); +if (lean_is_exclusive(x_120)) { + lean_ctor_release(x_120, 0); + lean_ctor_release(x_120, 1); + x_125 = x_120; +} else { + lean_dec_ref(x_120); + x_125 = lean_box(0); +} +x_126 = lean_ctor_get(x_121, 0); +lean_inc(x_126); +x_127 = lean_ctor_get(x_121, 1); +lean_inc(x_127); +if (lean_is_exclusive(x_121)) { + lean_ctor_release(x_121, 0); + lean_ctor_release(x_121, 1); + x_128 = x_121; +} else { + lean_dec_ref(x_121); + x_128 = lean_box(0); +} +x_129 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_129, 0, x_127); +lean_ctor_set(x_129, 1, x_126); +x_130 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_130, 0, x_129); +if (lean_is_scalar(x_125)) { + x_131 = lean_alloc_ctor(0, 2, 0); +} else { + x_131 = x_125; +} +lean_ctor_set(x_131, 0, x_130); +lean_ctor_set(x_131, 1, x_124); +if (lean_is_scalar(x_128)) { + x_132 = lean_alloc_ctor(0, 2, 0); +} else { + x_132 = x_128; +} +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_123); +x_12 = x_132; +x_13 = x_122; +goto block_54; +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +x_133 = lean_ctor_get(x_118, 1); +lean_inc(x_133); +lean_dec(x_118); +x_134 = lean_ctor_get(x_119, 1); +lean_inc(x_134); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_135 = x_119; +} else { + lean_dec_ref(x_119); + x_135 = lean_box(0); +} +x_136 = lean_ctor_get(x_120, 0); +lean_inc(x_136); +x_137 = lean_ctor_get(x_120, 1); +lean_inc(x_137); +if (lean_is_exclusive(x_120)) { + lean_ctor_release(x_120, 0); + lean_ctor_release(x_120, 1); + x_138 = x_120; +} else { + lean_dec_ref(x_120); + x_138 = lean_box(0); +} +if (lean_is_scalar(x_138)) { + x_139 = lean_alloc_ctor(1, 2, 0); +} else { + x_139 = x_138; +} +lean_ctor_set(x_139, 0, x_136); +lean_ctor_set(x_139, 1, x_137); +if (lean_is_scalar(x_135)) { + x_140 = lean_alloc_ctor(0, 2, 0); +} else { + x_140 = x_135; +} +lean_ctor_set(x_140, 0, x_139); +lean_ctor_set(x_140, 1, x_134); +x_12 = x_140; +x_13 = x_133; +goto block_54; +} +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_141 = lean_ctor_get(x_118, 0); +lean_inc(x_141); +x_142 = lean_ctor_get(x_118, 1); +lean_inc(x_142); +if (lean_is_exclusive(x_118)) { + lean_ctor_release(x_118, 0); + lean_ctor_release(x_118, 1); + x_143 = x_118; +} else { + lean_dec_ref(x_118); + x_143 = lean_box(0); +} +if (lean_is_scalar(x_143)) { + x_144 = lean_alloc_ctor(1, 2, 0); +} else { + x_144 = x_143; +} +lean_ctor_set(x_144, 0, x_141); +lean_ctor_set(x_144, 1, x_142); +return x_144; +} +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_2); +lean_ctor_set(x_10, 1, x_1); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_7); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +return x_13; +} +} +static lean_object* _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLib_recCollectLocalModules_go___lambda__1___boxed), 9, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("lean", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("imports", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_recCollectLocalModules_go___closed__2; +x_2 = l_Lake_LeanLib_recCollectLocalModules_go___closed__3; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; uint8_t x_12; +x_11 = l_Lake_LeanLib_recCollectLocalModules_go___closed__1; +x_12 = l_Lean_HashSetImp_contains___at_Lake_LeanLib_recCollectLocalModules_go___spec__1(x_4, x_2); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = l_Lake_LeanLib_recCollectLocalModules_go___closed__4; +lean_inc(x_2); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_2); +lean_ctor_set(x_14, 1, x_13); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_15 = lean_apply_6(x_5, x_14, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_15); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_17 = lean_ctor_get(x_15, 0); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_2); +x_19 = l_Lean_HashSetImp_insert___at_Lake_LeanLib_recCollectLocalModules_go___spec__3(x_4, x_2); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +if (lean_obj_tag(x_20) == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; size_t x_26; size_t x_27; lean_object* x_28; +lean_free_object(x_15); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_dec(x_17); +x_22 = lean_ctor_get(x_20, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_19); +lean_ctor_set(x_24, 1, x_3); +x_25 = lean_array_get_size(x_22); +x_26 = lean_usize_of_nat(x_25); +lean_dec(x_25); +x_27 = 0; +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +x_28 = l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules_go___spec__9(x_1, x_22, x_26, x_27, x_24, x_5, x_6, x_7, x_23, x_21, x_18); +lean_dec(x_22); +if (lean_obj_tag(x_28) == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_28, 1); +lean_inc(x_32); +lean_dec(x_28); +x_33 = lean_ctor_get(x_29, 1); +lean_inc(x_33); +lean_dec(x_29); +x_34 = lean_ctor_get(x_30, 1); +lean_inc(x_34); +lean_dec(x_30); +x_35 = lean_ctor_get(x_31, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_31, 1); +lean_inc(x_36); +lean_dec(x_31); +x_37 = lean_array_push(x_36, x_2); +x_38 = lean_box(0); +x_39 = lean_apply_9(x_11, x_35, x_37, x_38, x_5, x_6, x_7, x_34, x_33, x_32); +return x_39; +} +else +{ +uint8_t x_40; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +x_40 = !lean_is_exclusive(x_28); +if (x_40 == 0) +{ +lean_object* x_41; uint8_t x_42; +x_41 = lean_ctor_get(x_28, 0); +lean_dec(x_41); +x_42 = !lean_is_exclusive(x_29); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_29, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_30); +if (x_44 == 0) +{ +return x_28; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_30, 0); +x_46 = lean_ctor_get(x_30, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_30); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_29, 0, x_47); +return x_28; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_29, 1); +lean_inc(x_48); +lean_dec(x_29); +x_49 = lean_ctor_get(x_30, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_30, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_30)) { + lean_ctor_release(x_30, 0); + lean_ctor_release(x_30, 1); + x_51 = x_30; +} else { + lean_dec_ref(x_30); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +lean_ctor_set(x_28, 0, x_53); +return x_28; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_54 = lean_ctor_get(x_28, 1); +lean_inc(x_54); +lean_dec(x_28); +x_55 = lean_ctor_get(x_29, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_56 = x_29; +} else { + lean_dec_ref(x_29); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_30, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_30, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_30)) { + lean_ctor_release(x_30, 0); + lean_ctor_release(x_30, 1); + x_59 = x_30; +} else { + lean_dec_ref(x_30); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +if (lean_is_scalar(x_56)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_56; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_55); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_54); +return x_62; +} +} +} +else +{ +uint8_t x_63; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +x_63 = !lean_is_exclusive(x_28); +if (x_63 == 0) +{ +return x_28; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_28, 0); +x_65 = lean_ctor_get(x_28, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_28); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +return x_66; +} +} +} +else +{ +uint8_t x_67; +lean_dec(x_19); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +x_67 = !lean_is_exclusive(x_17); +if (x_67 == 0) +{ +lean_object* x_68; uint8_t x_69; +x_68 = lean_ctor_get(x_17, 0); +lean_dec(x_68); +x_69 = !lean_is_exclusive(x_20); +if (x_69 == 0) +{ +return x_15; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_20, 0); +x_71 = lean_ctor_get(x_20, 1); +lean_inc(x_71); +lean_inc(x_70); +lean_dec(x_20); +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +lean_ctor_set(x_17, 0, x_72); +return x_15; +} +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_73 = lean_ctor_get(x_17, 1); +lean_inc(x_73); +lean_dec(x_17); +x_74 = lean_ctor_get(x_20, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_76 = x_20; +} else { + lean_dec_ref(x_20); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_76)) { + x_77 = lean_alloc_ctor(1, 2, 0); +} else { + x_77 = x_76; +} +lean_ctor_set(x_77, 0, x_74); +lean_ctor_set(x_77, 1, x_75); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_73); +lean_ctor_set(x_15, 0, x_78); +return x_15; +} +} +} +else +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_79 = lean_ctor_get(x_15, 0); +x_80 = lean_ctor_get(x_15, 1); +lean_inc(x_80); +lean_inc(x_79); +lean_dec(x_15); +lean_inc(x_2); +x_81 = l_Lean_HashSetImp_insert___at_Lake_LeanLib_recCollectLocalModules_go___spec__3(x_4, x_2); +x_82 = lean_ctor_get(x_79, 0); +lean_inc(x_82); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; size_t x_88; size_t x_89; lean_object* x_90; +x_83 = lean_ctor_get(x_79, 1); +lean_inc(x_83); +lean_dec(x_79); +x_84 = lean_ctor_get(x_82, 0); +lean_inc(x_84); +x_85 = lean_ctor_get(x_82, 1); +lean_inc(x_85); +lean_dec(x_82); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_81); +lean_ctor_set(x_86, 1, x_3); +x_87 = lean_array_get_size(x_84); +x_88 = lean_usize_of_nat(x_87); +lean_dec(x_87); +x_89 = 0; +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +x_90 = l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules_go___spec__9(x_1, x_84, x_88, x_89, x_86, x_5, x_6, x_7, x_85, x_83, x_80); +lean_dec(x_84); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 0); +lean_inc(x_91); +x_92 = lean_ctor_get(x_91, 0); +lean_inc(x_92); +if (lean_obj_tag(x_92) == 0) +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_93 = lean_ctor_get(x_92, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +lean_dec(x_90); +x_95 = lean_ctor_get(x_91, 1); +lean_inc(x_95); +lean_dec(x_91); +x_96 = lean_ctor_get(x_92, 1); +lean_inc(x_96); +lean_dec(x_92); +x_97 = lean_ctor_get(x_93, 0); +lean_inc(x_97); +x_98 = lean_ctor_get(x_93, 1); +lean_inc(x_98); +lean_dec(x_93); +x_99 = lean_array_push(x_98, x_2); +x_100 = lean_box(0); +x_101 = lean_apply_9(x_11, x_97, x_99, x_100, x_5, x_6, x_7, x_96, x_95, x_94); +return x_101; +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +x_102 = lean_ctor_get(x_90, 1); +lean_inc(x_102); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_103 = x_90; +} else { + lean_dec_ref(x_90); + x_103 = lean_box(0); +} +x_104 = lean_ctor_get(x_91, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_91)) { + lean_ctor_release(x_91, 0); + lean_ctor_release(x_91, 1); + x_105 = x_91; +} else { + lean_dec_ref(x_91); + x_105 = lean_box(0); +} +x_106 = lean_ctor_get(x_92, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_92, 1); +lean_inc(x_107); +if (lean_is_exclusive(x_92)) { + lean_ctor_release(x_92, 0); + lean_ctor_release(x_92, 1); + x_108 = x_92; +} else { + lean_dec_ref(x_92); + x_108 = lean_box(0); +} +if (lean_is_scalar(x_108)) { + x_109 = lean_alloc_ctor(1, 2, 0); +} else { + x_109 = x_108; +} +lean_ctor_set(x_109, 0, x_106); +lean_ctor_set(x_109, 1, x_107); +if (lean_is_scalar(x_105)) { + x_110 = lean_alloc_ctor(0, 2, 0); +} else { + x_110 = x_105; +} +lean_ctor_set(x_110, 0, x_109); +lean_ctor_set(x_110, 1, x_104); +if (lean_is_scalar(x_103)) { + x_111 = lean_alloc_ctor(0, 2, 0); +} else { + x_111 = x_103; +} +lean_ctor_set(x_111, 0, x_110); +lean_ctor_set(x_111, 1, x_102); +return x_111; +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +x_112 = lean_ctor_get(x_90, 0); +lean_inc(x_112); +x_113 = lean_ctor_get(x_90, 1); +lean_inc(x_113); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_114 = x_90; +} else { + lean_dec_ref(x_90); + x_114 = lean_box(0); +} +if (lean_is_scalar(x_114)) { + x_115 = lean_alloc_ctor(1, 2, 0); +} else { + x_115 = x_114; +} +lean_ctor_set(x_115, 0, x_112); +lean_ctor_set(x_115, 1, x_113); +return x_115; +} +} +else +{ +lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +lean_dec(x_81); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +x_116 = lean_ctor_get(x_79, 1); +lean_inc(x_116); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_117 = x_79; +} else { + lean_dec_ref(x_79); + x_117 = lean_box(0); +} +x_118 = lean_ctor_get(x_82, 0); +lean_inc(x_118); +x_119 = lean_ctor_get(x_82, 1); +lean_inc(x_119); +if (lean_is_exclusive(x_82)) { + lean_ctor_release(x_82, 0); + lean_ctor_release(x_82, 1); + x_120 = x_82; +} else { + lean_dec_ref(x_82); + x_120 = lean_box(0); +} +if (lean_is_scalar(x_120)) { + x_121 = lean_alloc_ctor(1, 2, 0); +} else { + x_121 = x_120; +} +lean_ctor_set(x_121, 0, x_118); +lean_ctor_set(x_121, 1, x_119); +if (lean_is_scalar(x_117)) { + x_122 = lean_alloc_ctor(0, 2, 0); +} else { + x_122 = x_117; +} +lean_ctor_set(x_122, 0, x_121); +lean_ctor_set(x_122, 1, x_116); +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_122); +lean_ctor_set(x_123, 1, x_80); +return x_123; +} +} +} +else +{ +uint8_t x_124; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_124 = !lean_is_exclusive(x_15); +if (x_124 == 0) +{ +return x_15; +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; +x_125 = lean_ctor_get(x_15, 0); +x_126 = lean_ctor_get(x_15, 1); +lean_inc(x_126); +lean_inc(x_125); +lean_dec(x_15); +x_127 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_127, 0, x_125); +lean_ctor_set(x_127, 1, x_126); +return x_127; +} +} +} +else +{ +lean_object* x_128; lean_object* x_129; +lean_dec(x_2); +x_128 = lean_box(0); +x_129 = lean_apply_9(x_11, x_4, x_3, x_128, x_5, x_6, x_7, x_8, x_9, x_10); +return x_129; +} +} +} +LEAN_EXPORT lean_object* l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_List_elem___at_Lake_LeanLib_recCollectLocalModules_go___spec__2(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_LeanLib_recCollectLocalModules_go___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lean_HashSetImp_contains___at_Lake_LeanLib_recCollectLocalModules_go___spec__1(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_replace___at_Lake_LeanLib_recCollectLocalModules_go___spec__8(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules_go___spec__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules_go___spec__9(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +lean_dec(x_1); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_LeanLib_recCollectLocalModules_go___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules_go___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; +x_11 = l_Lake_LeanLib_recCollectLocalModules_go(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; uint8_t x_55; +x_55 = lean_usize_dec_lt(x_4, x_3); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_5); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_11); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_59 = lean_array_uget(x_2, x_4); +x_60 = lean_ctor_get(x_5, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_5, 1); +lean_inc(x_61); +lean_dec(x_5); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_62 = l_Lake_LeanLib_recCollectLocalModules_go(x_1, x_59, x_61, x_60, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_62) == 0) +{ +lean_object* x_63; lean_object* x_64; +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +x_64 = lean_ctor_get(x_63, 0); +lean_inc(x_64); +if (lean_obj_tag(x_64) == 0) +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; +x_65 = lean_ctor_get(x_64, 0); +lean_inc(x_65); +x_66 = lean_ctor_get(x_62, 1); +lean_inc(x_66); +lean_dec(x_62); +x_67 = lean_ctor_get(x_63, 1); +lean_inc(x_67); +lean_dec(x_63); +x_68 = !lean_is_exclusive(x_64); +if (x_68 == 0) +{ +lean_object* x_69; uint8_t x_70; +x_69 = lean_ctor_get(x_64, 0); +lean_dec(x_69); +x_70 = !lean_is_exclusive(x_65); +if (x_70 == 0) +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_71 = lean_ctor_get(x_65, 0); +x_72 = lean_ctor_get(x_65, 1); +x_73 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_71); +x_74 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_64, 0, x_74); +lean_ctor_set(x_65, 1, x_67); +lean_ctor_set(x_65, 0, x_64); +x_12 = x_65; +x_13 = x_66; +goto block_54; +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_75 = lean_ctor_get(x_65, 0); +x_76 = lean_ctor_get(x_65, 1); +lean_inc(x_76); +lean_inc(x_75); +lean_dec(x_65); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_75); +x_78 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_64, 0, x_78); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_64); +lean_ctor_set(x_79, 1, x_67); +x_12 = x_79; +x_13 = x_66; +goto block_54; +} +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_80 = lean_ctor_get(x_64, 1); +lean_inc(x_80); +lean_dec(x_64); +x_81 = lean_ctor_get(x_65, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_65, 1); +lean_inc(x_82); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_83 = x_65; +} else { + lean_dec_ref(x_65); + x_83 = lean_box(0); +} +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_82); +lean_ctor_set(x_84, 1, x_81); +x_85 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_85, 0, x_84); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_83)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_83; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_67); +x_12 = x_87; +x_13 = x_66; +goto block_54; +} +} +else +{ +lean_object* x_88; uint8_t x_89; +x_88 = lean_ctor_get(x_62, 1); +lean_inc(x_88); +lean_dec(x_62); +x_89 = !lean_is_exclusive(x_63); +if (x_89 == 0) +{ +lean_object* x_90; uint8_t x_91; +x_90 = lean_ctor_get(x_63, 0); +lean_dec(x_90); +x_91 = !lean_is_exclusive(x_64); +if (x_91 == 0) +{ +x_12 = x_63; +x_13 = x_88; +goto block_54; +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_92 = lean_ctor_get(x_64, 0); +x_93 = lean_ctor_get(x_64, 1); +lean_inc(x_93); +lean_inc(x_92); +lean_dec(x_64); +x_94 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_94, 0, x_92); +lean_ctor_set(x_94, 1, x_93); +lean_ctor_set(x_63, 0, x_94); +x_12 = x_63; +x_13 = x_88; +goto block_54; +} +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_95 = lean_ctor_get(x_63, 1); +lean_inc(x_95); +lean_dec(x_63); +x_96 = lean_ctor_get(x_64, 0); +lean_inc(x_96); +x_97 = lean_ctor_get(x_64, 1); +lean_inc(x_97); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_98 = x_64; +} else { + lean_dec_ref(x_64); + x_98 = lean_box(0); +} +if (lean_is_scalar(x_98)) { + x_99 = lean_alloc_ctor(1, 2, 0); +} else { + x_99 = x_98; +} +lean_ctor_set(x_99, 0, x_96); +lean_ctor_set(x_99, 1, x_97); +x_100 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_100, 0, x_99); +lean_ctor_set(x_100, 1, x_95); +x_12 = x_100; +x_13 = x_88; +goto block_54; +} +} +} +else +{ +uint8_t x_101; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_101 = !lean_is_exclusive(x_62); +if (x_101 == 0) +{ +return x_62; +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_62, 0); +x_103 = lean_ctor_get(x_62, 1); +lean_inc(x_103); +lean_inc(x_102); +lean_dec(x_62); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_102); +lean_ctor_set(x_104, 1, x_103); +return x_104; +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +} +} +static lean_object* _init_l_Lake_LeanLib_recCollectLocalModules___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_recCollectLocalModules___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(8u); +x_2 = l_Lean_mkHashSetImp___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_recCollectLocalModules___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_recCollectLocalModules___closed__2; +x_2 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recCollectLocalModules(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_90; +lean_inc(x_1); +x_90 = l_Lake_LeanLib_getModuleArray(x_1, x_7); +if (lean_obj_tag(x_90) == 0) +{ +uint8_t x_91; +x_91 = !lean_is_exclusive(x_90); +if (x_91 == 0) +{ +lean_object* x_92; lean_object* x_93; +x_92 = lean_ctor_get(x_90, 1); +lean_ctor_set(x_90, 1, x_5); +x_93 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_93, 0, x_90); +lean_ctor_set(x_93, 1, x_6); +x_8 = x_93; +x_9 = x_92; +goto block_89; +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_94 = lean_ctor_get(x_90, 0); +x_95 = lean_ctor_get(x_90, 1); +lean_inc(x_95); +lean_inc(x_94); +lean_dec(x_90); +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_94); +lean_ctor_set(x_96, 1, x_5); +x_97 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_97, 0, x_96); +lean_ctor_set(x_97, 1, x_6); +x_8 = x_97; +x_9 = x_95; +goto block_89; +} +} +else +{ +uint8_t x_98; +x_98 = !lean_is_exclusive(x_90); +if (x_98 == 0) +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_99 = lean_ctor_get(x_90, 0); +x_100 = lean_ctor_get(x_90, 1); +x_101 = lean_io_error_to_string(x_99); +x_102 = 3; +x_103 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_102); +x_104 = lean_array_get_size(x_5); +x_105 = lean_array_push(x_5, x_103); +lean_ctor_set(x_90, 1, x_105); +lean_ctor_set(x_90, 0, x_104); +x_106 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_106, 0, x_90); +lean_ctor_set(x_106, 1, x_6); +x_8 = x_106; +x_9 = x_100; +goto block_89; +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; uint8_t x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_107 = lean_ctor_get(x_90, 0); +x_108 = lean_ctor_get(x_90, 1); +lean_inc(x_108); +lean_inc(x_107); +lean_dec(x_90); +x_109 = lean_io_error_to_string(x_107); +x_110 = 3; +x_111 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set_uint8(x_111, sizeof(void*)*1, x_110); +x_112 = lean_array_get_size(x_5); +x_113 = lean_array_push(x_5, x_111); +x_114 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_114, 0, x_112); +lean_ctor_set(x_114, 1, x_113); +x_115 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_115, 0, x_114); +lean_ctor_set(x_115, 1, x_6); +x_8 = x_115; +x_9 = x_108; +goto block_89; +} +} +block_89: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; size_t x_15; size_t x_16; lean_object* x_17; lean_object* x_18; +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_array_get_size(x_12); +x_15 = lean_usize_of_nat(x_14); +lean_dec(x_14); +x_16 = 0; +x_17 = l_Lake_LeanLib_recCollectLocalModules___closed__3; +x_18 = l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules___spec__1(x_1, x_12, x_15, x_16, x_17, x_2, x_3, x_4, x_13, x_11, x_9); +lean_dec(x_12); +lean_dec(x_1); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +if (lean_obj_tag(x_20) == 0) +{ +lean_object* x_21; uint8_t x_22; +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +x_22 = !lean_is_exclusive(x_18); +if (x_22 == 0) +{ +lean_object* x_23; uint8_t x_24; +x_23 = lean_ctor_get(x_18, 0); +lean_dec(x_23); +x_24 = !lean_is_exclusive(x_19); +if (x_24 == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_19, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_20); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_20, 0); +lean_dec(x_27); +x_28 = lean_ctor_get(x_21, 1); +lean_inc(x_28); +lean_dec(x_21); +lean_ctor_set(x_20, 0, x_28); +return x_18; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_20, 1); +lean_inc(x_29); +lean_dec(x_20); +x_30 = lean_ctor_get(x_21, 1); +lean_inc(x_30); +lean_dec(x_21); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_29); +lean_ctor_set(x_19, 0, x_31); +return x_18; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_32 = lean_ctor_get(x_19, 1); +lean_inc(x_32); +lean_dec(x_19); +x_33 = lean_ctor_get(x_20, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_34 = x_20; +} else { + lean_dec_ref(x_20); + x_34 = lean_box(0); +} +x_35 = lean_ctor_get(x_21, 1); +lean_inc(x_35); +lean_dec(x_21); +if (lean_is_scalar(x_34)) { + x_36 = lean_alloc_ctor(0, 2, 0); +} else { + x_36 = x_34; +} +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_33); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_32); +lean_ctor_set(x_18, 0, x_37); +return x_18; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_38 = lean_ctor_get(x_18, 1); +lean_inc(x_38); +lean_dec(x_18); +x_39 = lean_ctor_get(x_19, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_40 = x_19; +} else { + lean_dec_ref(x_19); + x_40 = lean_box(0); +} +x_41 = lean_ctor_get(x_20, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_42 = x_20; +} else { + lean_dec_ref(x_20); + x_42 = lean_box(0); +} +x_43 = lean_ctor_get(x_21, 1); +lean_inc(x_43); +lean_dec(x_21); +if (lean_is_scalar(x_42)) { + x_44 = lean_alloc_ctor(0, 2, 0); +} else { + x_44 = x_42; +} +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_41); +if (lean_is_scalar(x_40)) { + x_45 = lean_alloc_ctor(0, 2, 0); +} else { + x_45 = x_40; +} +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_38); +return x_46; +} +} +else +{ +uint8_t x_47; +x_47 = !lean_is_exclusive(x_18); +if (x_47 == 0) +{ +lean_object* x_48; uint8_t x_49; +x_48 = lean_ctor_get(x_18, 0); +lean_dec(x_48); +x_49 = !lean_is_exclusive(x_19); +if (x_49 == 0) +{ +lean_object* x_50; uint8_t x_51; +x_50 = lean_ctor_get(x_19, 0); +lean_dec(x_50); +x_51 = !lean_is_exclusive(x_20); +if (x_51 == 0) +{ +return x_18; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get(x_20, 1); +lean_inc(x_53); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set(x_54, 1, x_53); +lean_ctor_set(x_19, 0, x_54); +return x_18; +} +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_55 = lean_ctor_get(x_19, 1); +lean_inc(x_55); +lean_dec(x_19); +x_56 = lean_ctor_get(x_20, 0); +lean_inc(x_56); +x_57 = lean_ctor_get(x_20, 1); +lean_inc(x_57); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_58 = x_20; +} else { + lean_dec_ref(x_20); + x_58 = lean_box(0); +} +if (lean_is_scalar(x_58)) { + x_59 = lean_alloc_ctor(1, 2, 0); +} else { + x_59 = x_58; +} +lean_ctor_set(x_59, 0, x_56); +lean_ctor_set(x_59, 1, x_57); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_55); +lean_ctor_set(x_18, 0, x_60); +return x_18; +} +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_61 = lean_ctor_get(x_18, 1); +lean_inc(x_61); +lean_dec(x_18); +x_62 = lean_ctor_get(x_19, 1); +lean_inc(x_62); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_63 = x_19; +} else { + lean_dec_ref(x_19); + x_63 = lean_box(0); +} +x_64 = lean_ctor_get(x_20, 0); +lean_inc(x_64); +x_65 = lean_ctor_get(x_20, 1); +lean_inc(x_65); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_66 = x_20; +} else { + lean_dec_ref(x_20); + x_66 = lean_box(0); +} +if (lean_is_scalar(x_66)) { + x_67 = lean_alloc_ctor(1, 2, 0); +} else { + x_67 = x_66; +} +lean_ctor_set(x_67, 0, x_64); +lean_ctor_set(x_67, 1, x_65); +if (lean_is_scalar(x_63)) { + x_68 = lean_alloc_ctor(0, 2, 0); +} else { + x_68 = x_63; +} +lean_ctor_set(x_68, 0, x_67); +lean_ctor_set(x_68, 1, x_62); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_61); +return x_69; +} +} +} +else +{ +uint8_t x_70; +x_70 = !lean_is_exclusive(x_18); +if (x_70 == 0) +{ +return x_18; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_71 = lean_ctor_get(x_18, 0); +x_72 = lean_ctor_get(x_18, 1); +lean_inc(x_72); +lean_inc(x_71); +lean_dec(x_18); +x_73 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_73, 0, x_71); +lean_ctor_set(x_73, 1, x_72); +return x_73; +} +} +} +else +{ +uint8_t x_74; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_74 = !lean_is_exclusive(x_8); +if (x_74 == 0) +{ +lean_object* x_75; uint8_t x_76; +x_75 = lean_ctor_get(x_8, 0); +lean_dec(x_75); +x_76 = !lean_is_exclusive(x_10); +if (x_76 == 0) +{ +lean_object* x_77; +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_8); +lean_ctor_set(x_77, 1, x_9); +return x_77; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_78 = lean_ctor_get(x_10, 0); +x_79 = lean_ctor_get(x_10, 1); +lean_inc(x_79); +lean_inc(x_78); +lean_dec(x_10); +x_80 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set(x_80, 1, x_79); +lean_ctor_set(x_8, 0, x_80); +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_8); +lean_ctor_set(x_81, 1, x_9); +return x_81; +} +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_82 = lean_ctor_get(x_8, 1); +lean_inc(x_82); +lean_dec(x_8); +x_83 = lean_ctor_get(x_10, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_10, 1); +lean_inc(x_84); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_85 = x_10; +} else { + lean_dec_ref(x_10); + x_85 = lean_box(0); +} +if (lean_is_scalar(x_85)) { + x_86 = lean_alloc_ctor(1, 2, 0); +} else { + x_86 = x_85; +} +lean_ctor_set(x_86, 0, x_83); +lean_ctor_set(x_86, 1, x_84); +x_87 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_82); +x_88 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_9); +return x_88; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_LeanLib_recCollectLocalModules___spec__1(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +lean_dec(x_1); +return x_14; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("modules", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_modulesFacetConfig___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLib_recCollectLocalModules), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_modulesFacetConfig___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_modulesFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_modulesFacetConfig___closed__4; +return x_1; +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanArts", 8); +return x_1; +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; +x_11 = lean_usize_dec_eq(x_2, x_3); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_array_uget(x_1, x_2); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__2; +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_13); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_15 = lean_apply_6(x_5, x_14, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; size_t x_23; size_t x_24; +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_dec(x_17); +x_22 = l_Lake_BuildJob_mix___rarg(x_4, x_20); +x_23 = 1; +x_24 = lean_usize_add(x_2, x_23); +x_2 = x_24; +x_4 = x_22; +x_8 = x_21; +x_9 = x_19; +x_10 = x_18; +goto _start; +} +else +{ +uint8_t x_26; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_26 = !lean_is_exclusive(x_15); +if (x_26 == 0) +{ +lean_object* x_27; uint8_t x_28; +x_27 = lean_ctor_get(x_15, 0); +lean_dec(x_27); +x_28 = !lean_is_exclusive(x_16); +if (x_28 == 0) +{ +lean_object* x_29; uint8_t x_30; +x_29 = lean_ctor_get(x_16, 0); +lean_dec(x_29); +x_30 = !lean_is_exclusive(x_17); +if (x_30 == 0) +{ +return x_15; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_17, 0); +x_32 = lean_ctor_get(x_17, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_17); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +lean_ctor_set(x_16, 0, x_33); +return x_15; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_16, 1); +lean_inc(x_34); +lean_dec(x_16); +x_35 = lean_ctor_get(x_17, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_17, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_37 = x_17; +} else { + lean_dec_ref(x_17); + x_37 = lean_box(0); +} +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_36); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_34); +lean_ctor_set(x_15, 0, x_39); +return x_15; +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_40 = lean_ctor_get(x_15, 1); +lean_inc(x_40); +lean_dec(x_15); +x_41 = lean_ctor_get(x_16, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_42 = x_16; +} else { + lean_dec_ref(x_16); + x_42 = lean_box(0); +} +x_43 = lean_ctor_get(x_17, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_17, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_45 = x_17; +} else { + lean_dec_ref(x_17); + x_45 = lean_box(0); +} +if (lean_is_scalar(x_45)) { + x_46 = lean_alloc_ctor(1, 2, 0); +} else { + x_46 = x_45; +} +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_44); +if (lean_is_scalar(x_42)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_42; +} +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_41); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_40); +return x_48; +} +} +} +else +{ +uint8_t x_49; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_49 = !lean_is_exclusive(x_15); +if (x_49 == 0) +{ +return x_15; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_15, 0); +x_51 = lean_ctor_get(x_15, 1); +lean_inc(x_51); +lean_inc(x_50); +lean_dec(x_15); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_50); +lean_ctor_set(x_52, 1, x_51); +return x_52; +} +} +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_4); +lean_ctor_set(x_53, 1, x_8); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_9); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_10); +return x_55; +} +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildLean___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildLean___closed__2() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_2 = 0; +x_3 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildLean___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_recBuildLean___closed__1; +x_2 = l_Lake_LeanLib_recBuildLean___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildLean___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_LeanLib_recBuildLean___closed__3; +x_2 = lean_task_pure(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildLean___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildLean___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_recBuildLean___closed__4; +x_2 = l_Lake_LeanLib_recBuildLean___closed__5; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildLean(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Lake_LeanLib_modulesFacetConfig___closed__2; +x_9 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +x_10 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +uint8_t x_13; +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_14 = lean_ctor_get(x_10, 1); +x_15 = lean_ctor_get(x_10, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_11); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; uint8_t x_19; +x_17 = lean_ctor_get(x_11, 1); +x_18 = lean_ctor_get(x_11, 0); +lean_dec(x_18); +x_19 = !lean_is_exclusive(x_12); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_20 = lean_ctor_get(x_12, 0); +x_21 = lean_ctor_get(x_12, 1); +x_22 = lean_array_get_size(x_20); +x_23 = lean_unsigned_to_nat(0u); +x_24 = lean_nat_dec_lt(x_23, x_22); +if (x_24 == 0) +{ +lean_object* x_25; +lean_dec(x_22); +lean_dec(x_20); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_25 = l_Lake_LeanLib_recBuildLean___closed__6; +lean_ctor_set(x_12, 0, x_25); +return x_10; +} +else +{ +uint8_t x_26; +x_26 = lean_nat_dec_le(x_22, x_22); +if (x_26 == 0) +{ +lean_object* x_27; +lean_dec(x_22); +lean_dec(x_20); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_27 = l_Lake_LeanLib_recBuildLean___closed__6; +lean_ctor_set(x_12, 0, x_27); +return x_10; +} +else +{ +size_t x_28; size_t x_29; lean_object* x_30; lean_object* x_31; +lean_free_object(x_12); +lean_free_object(x_11); +lean_free_object(x_10); +x_28 = 0; +x_29 = lean_usize_of_nat(x_22); +lean_dec(x_22); +x_30 = l_Lake_LeanLib_recBuildLean___closed__6; +x_31 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1(x_20, x_28, x_29, x_30, x_2, x_3, x_4, x_21, x_17, x_14); +lean_dec(x_20); +return x_31; +} +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_32 = lean_ctor_get(x_12, 0); +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_inc(x_32); +lean_dec(x_12); +x_34 = lean_array_get_size(x_32); +x_35 = lean_unsigned_to_nat(0u); +x_36 = lean_nat_dec_lt(x_35, x_34); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; +lean_dec(x_34); +lean_dec(x_32); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_37 = l_Lake_LeanLib_recBuildLean___closed__6; +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_33); +lean_ctor_set(x_11, 0, x_38); +return x_10; +} +else +{ +uint8_t x_39; +x_39 = lean_nat_dec_le(x_34, x_34); +if (x_39 == 0) +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_34); +lean_dec(x_32); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_40 = l_Lake_LeanLib_recBuildLean___closed__6; +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_33); +lean_ctor_set(x_11, 0, x_41); +return x_10; +} +else +{ +size_t x_42; size_t x_43; lean_object* x_44; lean_object* x_45; +lean_free_object(x_11); +lean_free_object(x_10); +x_42 = 0; +x_43 = lean_usize_of_nat(x_34); +lean_dec(x_34); +x_44 = l_Lake_LeanLib_recBuildLean___closed__6; +x_45 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1(x_32, x_42, x_43, x_44, x_2, x_3, x_4, x_33, x_17, x_14); +lean_dec(x_32); +return x_45; +} +} +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; +x_46 = lean_ctor_get(x_11, 1); +lean_inc(x_46); +lean_dec(x_11); +x_47 = lean_ctor_get(x_12, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_12, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_49 = x_12; +} else { + lean_dec_ref(x_12); + x_49 = lean_box(0); +} +x_50 = lean_array_get_size(x_47); +x_51 = lean_unsigned_to_nat(0u); +x_52 = lean_nat_dec_lt(x_51, x_50); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +lean_dec(x_50); +lean_dec(x_47); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_53 = l_Lake_LeanLib_recBuildLean___closed__6; +if (lean_is_scalar(x_49)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_49; +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_48); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_46); +lean_ctor_set(x_10, 0, x_55); +return x_10; +} +else +{ +uint8_t x_56; +x_56 = lean_nat_dec_le(x_50, x_50); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +lean_dec(x_50); +lean_dec(x_47); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_57 = l_Lake_LeanLib_recBuildLean___closed__6; +if (lean_is_scalar(x_49)) { + x_58 = lean_alloc_ctor(0, 2, 0); +} else { + x_58 = x_49; +} +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_48); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_46); +lean_ctor_set(x_10, 0, x_59); +return x_10; +} +else +{ +size_t x_60; size_t x_61; lean_object* x_62; lean_object* x_63; +lean_dec(x_49); +lean_free_object(x_10); +x_60 = 0; +x_61 = lean_usize_of_nat(x_50); +lean_dec(x_50); +x_62 = l_Lake_LeanLib_recBuildLean___closed__6; +x_63 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1(x_47, x_60, x_61, x_62, x_2, x_3, x_4, x_48, x_46, x_14); +lean_dec(x_47); +return x_63; +} +} +} +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; uint8_t x_72; +x_64 = lean_ctor_get(x_10, 1); +lean_inc(x_64); +lean_dec(x_10); +x_65 = lean_ctor_get(x_11, 1); +lean_inc(x_65); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_66 = x_11; +} else { + lean_dec_ref(x_11); + x_66 = lean_box(0); +} +x_67 = lean_ctor_get(x_12, 0); +lean_inc(x_67); +x_68 = lean_ctor_get(x_12, 1); +lean_inc(x_68); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_69 = x_12; +} else { + lean_dec_ref(x_12); + x_69 = lean_box(0); +} +x_70 = lean_array_get_size(x_67); +x_71 = lean_unsigned_to_nat(0u); +x_72 = lean_nat_dec_lt(x_71, x_70); +if (x_72 == 0) +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_70); +lean_dec(x_67); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_73 = l_Lake_LeanLib_recBuildLean___closed__6; +if (lean_is_scalar(x_69)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_69; +} +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_68); +if (lean_is_scalar(x_66)) { + x_75 = lean_alloc_ctor(0, 2, 0); +} else { + x_75 = x_66; +} +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_65); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_64); +return x_76; +} +else +{ +uint8_t x_77; +x_77 = lean_nat_dec_le(x_70, x_70); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_dec(x_70); +lean_dec(x_67); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_78 = l_Lake_LeanLib_recBuildLean___closed__6; +if (lean_is_scalar(x_69)) { + x_79 = lean_alloc_ctor(0, 2, 0); +} else { + x_79 = x_69; +} +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_68); +if (lean_is_scalar(x_66)) { + x_80 = lean_alloc_ctor(0, 2, 0); +} else { + x_80 = x_66; +} +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_65); +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_64); +return x_81; +} +else +{ +size_t x_82; size_t x_83; lean_object* x_84; lean_object* x_85; +lean_dec(x_69); +lean_dec(x_66); +x_82 = 0; +x_83 = lean_usize_of_nat(x_70); +lean_dec(x_70); +x_84 = l_Lake_LeanLib_recBuildLean___closed__6; +x_85 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1(x_67, x_82, x_83, x_84, x_2, x_3, x_4, x_68, x_65, x_64); +lean_dec(x_67); +return x_85; +} +} +} +} +else +{ +uint8_t x_86; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_86 = !lean_is_exclusive(x_10); +if (x_86 == 0) +{ +lean_object* x_87; uint8_t x_88; +x_87 = lean_ctor_get(x_10, 0); +lean_dec(x_87); +x_88 = !lean_is_exclusive(x_11); +if (x_88 == 0) +{ +lean_object* x_89; uint8_t x_90; +x_89 = lean_ctor_get(x_11, 0); +lean_dec(x_89); +x_90 = !lean_is_exclusive(x_12); +if (x_90 == 0) +{ +return x_10; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_91 = lean_ctor_get(x_12, 0); +x_92 = lean_ctor_get(x_12, 1); +lean_inc(x_92); +lean_inc(x_91); +lean_dec(x_12); +x_93 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_93, 0, x_91); +lean_ctor_set(x_93, 1, x_92); +lean_ctor_set(x_11, 0, x_93); +return x_10; +} +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_94 = lean_ctor_get(x_11, 1); +lean_inc(x_94); +lean_dec(x_11); +x_95 = lean_ctor_get(x_12, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_12, 1); +lean_inc(x_96); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_97 = x_12; +} else { + lean_dec_ref(x_12); + x_97 = lean_box(0); +} +if (lean_is_scalar(x_97)) { + x_98 = lean_alloc_ctor(1, 2, 0); +} else { + x_98 = x_97; +} +lean_ctor_set(x_98, 0, x_95); +lean_ctor_set(x_98, 1, x_96); +x_99 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_99, 0, x_98); +lean_ctor_set(x_99, 1, x_94); +lean_ctor_set(x_10, 0, x_99); +return x_10; +} +} +else +{ +lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +x_100 = lean_ctor_get(x_10, 1); +lean_inc(x_100); +lean_dec(x_10); +x_101 = lean_ctor_get(x_11, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_102 = x_11; +} else { + lean_dec_ref(x_11); + x_102 = lean_box(0); +} +x_103 = lean_ctor_get(x_12, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_12, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_105 = x_12; +} else { + lean_dec_ref(x_12); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +if (lean_is_scalar(x_102)) { + x_107 = lean_alloc_ctor(0, 2, 0); +} else { + x_107 = x_102; +} +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_101); +x_108 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_108, 0, x_107); +lean_ctor_set(x_108, 1, x_100); +return x_108; +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_109 = !lean_is_exclusive(x_10); +if (x_109 == 0) +{ +return x_10; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_10, 0); +x_111 = lean_ctor_get(x_10, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_10); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_dec(x_3); +x_4 = lean_box(0); +lean_ctor_set(x_1, 0, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +} +static lean_object* _init_l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___lambda__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_LeanLib_leanArtsFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLib_recBuildLean), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_leanArtsFacetConfig___closed__3; +x_2 = l_Lake_LeanLib_leanArtsFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_leanArtsFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_leanArtsFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_2); +x_10 = lean_apply_6(x_3, x_9, x_4, x_5, x_6, x_7, x_8); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__2(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; size_t x_18; size_t x_19; lean_object* x_20; lean_object* x_21; +lean_inc(x_4); +x_11 = lean_alloc_closure((void*)(l_Lake_LeanLib_recBuildStatic___lambda__1), 8, 1); +lean_closure_set(x_11, 0, x_4); +x_12 = lean_ctor_get(x_4, 0); +lean_inc(x_12); +lean_dec(x_4); +x_13 = lean_ctor_get(x_12, 1); +lean_inc(x_13); +lean_dec(x_12); +x_14 = lean_ctor_get(x_13, 8); +lean_inc(x_14); +lean_dec(x_13); +x_15 = lean_box(x_1); +x_16 = lean_apply_1(x_14, x_15); +x_17 = lean_array_get_size(x_16); +x_18 = lean_usize_of_nat(x_17); +lean_dec(x_17); +x_19 = 0; +x_20 = l_Array_mapMUnsafe_map___rarg(x_2, x_11, x_18, x_19, x_16); +x_21 = lean_apply_6(x_20, x_5, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; +x_22 = lean_ctor_get(x_21, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +if (lean_obj_tag(x_23) == 0) +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_21); +if (x_24 == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_21, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_22); +if (x_26 == 0) +{ +lean_object* x_27; uint8_t x_28; +x_27 = lean_ctor_get(x_22, 0); +lean_dec(x_27); +x_28 = !lean_is_exclusive(x_23); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_23, 0); +x_30 = l_Array_append___rarg(x_3, x_29); +lean_dec(x_29); +lean_ctor_set(x_23, 0, x_30); +return x_21; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_31 = lean_ctor_get(x_23, 0); +x_32 = lean_ctor_get(x_23, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_23); +x_33 = l_Array_append___rarg(x_3, x_31); +lean_dec(x_31); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_32); +lean_ctor_set(x_22, 0, x_34); +return x_21; +} +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_35 = lean_ctor_get(x_22, 1); +lean_inc(x_35); +lean_dec(x_22); +x_36 = lean_ctor_get(x_23, 0); +lean_inc(x_36); +x_37 = lean_ctor_get(x_23, 1); +lean_inc(x_37); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + lean_ctor_release(x_23, 1); + x_38 = x_23; +} else { + lean_dec_ref(x_23); + x_38 = lean_box(0); +} +x_39 = l_Array_append___rarg(x_3, x_36); +lean_dec(x_36); +if (lean_is_scalar(x_38)) { + x_40 = lean_alloc_ctor(0, 2, 0); +} else { + x_40 = x_38; +} +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_37); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_35); +lean_ctor_set(x_21, 0, x_41); +return x_21; +} +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_42 = lean_ctor_get(x_21, 1); +lean_inc(x_42); +lean_dec(x_21); +x_43 = lean_ctor_get(x_22, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_44 = x_22; +} else { + lean_dec_ref(x_22); + x_44 = lean_box(0); +} +x_45 = lean_ctor_get(x_23, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_23, 1); +lean_inc(x_46); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + lean_ctor_release(x_23, 1); + x_47 = x_23; +} else { + lean_dec_ref(x_23); + x_47 = lean_box(0); +} +x_48 = l_Array_append___rarg(x_3, x_45); +lean_dec(x_45); +if (lean_is_scalar(x_47)) { + x_49 = lean_alloc_ctor(0, 2, 0); +} else { + x_49 = x_47; +} +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_46); +if (lean_is_scalar(x_44)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_44; +} +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_43); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_42); +return x_51; +} +} +else +{ +uint8_t x_52; +lean_dec(x_3); +x_52 = !lean_is_exclusive(x_21); +if (x_52 == 0) +{ +lean_object* x_53; uint8_t x_54; +x_53 = lean_ctor_get(x_21, 0); +lean_dec(x_53); +x_54 = !lean_is_exclusive(x_22); +if (x_54 == 0) +{ +lean_object* x_55; uint8_t x_56; +x_55 = lean_ctor_get(x_22, 0); +lean_dec(x_55); +x_56 = !lean_is_exclusive(x_23); +if (x_56 == 0) +{ +return x_21; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_57 = lean_ctor_get(x_23, 0); +x_58 = lean_ctor_get(x_23, 1); +lean_inc(x_58); +lean_inc(x_57); +lean_dec(x_23); +x_59 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_59, 0, x_57); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_22, 0, x_59); +return x_21; +} +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_60 = lean_ctor_get(x_22, 1); +lean_inc(x_60); +lean_dec(x_22); +x_61 = lean_ctor_get(x_23, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_23, 1); +lean_inc(x_62); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + lean_ctor_release(x_23, 1); + x_63 = x_23; +} else { + lean_dec_ref(x_23); + x_63 = lean_box(0); +} +if (lean_is_scalar(x_63)) { + x_64 = lean_alloc_ctor(1, 2, 0); +} else { + x_64 = x_63; +} +lean_ctor_set(x_64, 0, x_61); +lean_ctor_set(x_64, 1, x_62); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_60); +lean_ctor_set(x_21, 0, x_65); +return x_21; +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_66 = lean_ctor_get(x_21, 1); +lean_inc(x_66); +lean_dec(x_21); +x_67 = lean_ctor_get(x_22, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_68 = x_22; +} else { + lean_dec_ref(x_22); + x_68 = lean_box(0); +} +x_69 = lean_ctor_get(x_23, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_23, 1); +lean_inc(x_70); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + lean_ctor_release(x_23, 1); + x_71 = x_23; +} else { + lean_dec_ref(x_23); + x_71 = lean_box(0); +} +if (lean_is_scalar(x_71)) { + x_72 = lean_alloc_ctor(1, 2, 0); +} else { + x_72 = x_71; +} +lean_ctor_set(x_72, 0, x_69); +lean_ctor_set(x_72, 1, x_70); +if (lean_is_scalar(x_68)) { + x_73 = lean_alloc_ctor(0, 2, 0); +} else { + x_73 = x_68; +} +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_67); +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_66); +return x_74; +} +} +} +else +{ +uint8_t x_75; +lean_dec(x_3); +x_75 = !lean_is_exclusive(x_21); +if (x_75 == 0) +{ +return x_21; +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_21, 0); +x_77 = lean_ctor_get(x_21, 1); +lean_inc(x_77); +lean_inc(x_76); +lean_dec(x_21); +x_78 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_78, 0, x_76); +lean_ctor_set(x_78, 1, x_77); +return x_78; +} +} +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("export", 6); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__3(uint8_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; uint8_t x_188; +x_183 = l_Lake_EquipT_instMonad___rarg(x_4); +x_184 = lean_box(x_1); +lean_inc(x_183); +x_185 = lean_alloc_closure((void*)(l_Lake_LeanLib_recBuildStatic___lambda__2___boxed), 10, 2); +lean_closure_set(x_185, 0, x_184); +lean_closure_set(x_185, 1, x_183); +x_186 = lean_array_get_size(x_5); +x_187 = lean_unsigned_to_nat(0u); +x_188 = lean_nat_dec_lt(x_187, x_186); +if (x_188 == 0) +{ +lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_186); +lean_dec(x_185); +lean_dec(x_183); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_189 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_190 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_190, 0, x_189); +lean_ctor_set(x_190, 1, x_9); +x_191 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_191, 0, x_190); +lean_ctor_set(x_191, 1, x_10); +x_12 = x_191; +x_13 = x_11; +goto block_182; +} +else +{ +uint8_t x_192; +x_192 = lean_nat_dec_le(x_186, x_186); +if (x_192 == 0) +{ +lean_object* x_193; lean_object* x_194; lean_object* x_195; +lean_dec(x_186); +lean_dec(x_185); +lean_dec(x_183); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_193 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_194 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_194, 0, x_193); +lean_ctor_set(x_194, 1, x_9); +x_195 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_195, 0, x_194); +lean_ctor_set(x_195, 1, x_10); +x_12 = x_195; +x_13 = x_11; +goto block_182; +} +else +{ +size_t x_196; size_t x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +x_196 = 0; +x_197 = lean_usize_of_nat(x_186); +lean_dec(x_186); +x_198 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_199 = l_Array_foldlMUnsafe_fold___rarg(x_183, x_185, x_5, x_196, x_197, x_198); +lean_inc(x_8); +x_200 = lean_apply_6(x_199, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_200) == 0) +{ +lean_object* x_201; lean_object* x_202; +x_201 = lean_ctor_get(x_200, 0); +lean_inc(x_201); +x_202 = lean_ctor_get(x_200, 1); +lean_inc(x_202); +lean_dec(x_200); +x_12 = x_201; +x_13 = x_202; +goto block_182; +} +else +{ +uint8_t x_203; +lean_dec(x_8); +lean_dec(x_2); +x_203 = !lean_is_exclusive(x_200); +if (x_203 == 0) +{ +return x_200; +} +else +{ +lean_object* x_204; lean_object* x_205; lean_object* x_206; +x_204 = lean_ctor_get(x_200, 0); +x_205 = lean_ctor_get(x_200, 1); +lean_inc(x_205); +lean_inc(x_204); +lean_dec(x_200); +x_206 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_206, 0, x_204); +lean_ctor_set(x_206, 1, x_205); +return x_206; +} +} +} +} +block_182: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +if (x_1 == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_12); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_16 = lean_ctor_get(x_12, 1); +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_19 = lean_ctor_get(x_14, 0); +x_20 = lean_ctor_get(x_14, 1); +x_21 = lean_ctor_get(x_2, 0); +lean_inc(x_21); +lean_dec(x_2); +x_22 = lean_ctor_get(x_21, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_21, 2); +lean_inc(x_23); +lean_dec(x_21); +x_24 = lean_ctor_get(x_23, 8); +lean_inc(x_24); +x_25 = l_System_FilePath_join(x_22, x_24); +x_26 = lean_ctor_get(x_23, 10); +lean_inc(x_26); +lean_dec(x_23); +x_27 = l_System_FilePath_join(x_25, x_26); +x_28 = lean_ctor_get(x_3, 5); +x_29 = l_Lake_nameToStaticLib(x_28); +x_30 = l_System_FilePath_join(x_27, x_29); +x_31 = l_Lake_buildStaticLib(x_30, x_19, x_8, x_13); +lean_dec(x_19); +if (lean_obj_tag(x_31) == 0) +{ +uint8_t x_32; +x_32 = !lean_is_exclusive(x_31); +if (x_32 == 0) +{ +lean_object* x_33; +x_33 = lean_ctor_get(x_31, 0); +lean_ctor_set(x_14, 0, x_33); +lean_ctor_set(x_31, 0, x_12); +return x_31; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_31, 0); +x_35 = lean_ctor_get(x_31, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_31); +lean_ctor_set(x_14, 0, x_34); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_12); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +else +{ +uint8_t x_37; +lean_free_object(x_14); +lean_dec(x_20); +lean_free_object(x_12); +lean_dec(x_16); +x_37 = !lean_is_exclusive(x_31); +if (x_37 == 0) +{ +return x_31; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_31, 0); +x_39 = lean_ctor_get(x_31, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_31); +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +return x_40; +} +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_41 = lean_ctor_get(x_14, 0); +x_42 = lean_ctor_get(x_14, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_14); +x_43 = lean_ctor_get(x_2, 0); +lean_inc(x_43); +lean_dec(x_2); +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_43, 2); +lean_inc(x_45); +lean_dec(x_43); +x_46 = lean_ctor_get(x_45, 8); +lean_inc(x_46); +x_47 = l_System_FilePath_join(x_44, x_46); +x_48 = lean_ctor_get(x_45, 10); +lean_inc(x_48); +lean_dec(x_45); +x_49 = l_System_FilePath_join(x_47, x_48); +x_50 = lean_ctor_get(x_3, 5); +x_51 = l_Lake_nameToStaticLib(x_50); +x_52 = l_System_FilePath_join(x_49, x_51); +x_53 = l_Lake_buildStaticLib(x_52, x_41, x_8, x_13); +lean_dec(x_41); +if (lean_obj_tag(x_53) == 0) +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_54 = lean_ctor_get(x_53, 0); +lean_inc(x_54); +x_55 = lean_ctor_get(x_53, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_53)) { + lean_ctor_release(x_53, 0); + lean_ctor_release(x_53, 1); + x_56 = x_53; +} else { + lean_dec_ref(x_53); + x_56 = lean_box(0); +} +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_54); +lean_ctor_set(x_57, 1, x_42); +lean_ctor_set(x_12, 0, x_57); +if (lean_is_scalar(x_56)) { + x_58 = lean_alloc_ctor(0, 2, 0); +} else { + x_58 = x_56; +} +lean_ctor_set(x_58, 0, x_12); +lean_ctor_set(x_58, 1, x_55); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +lean_dec(x_42); +lean_free_object(x_12); +lean_dec(x_16); +x_59 = lean_ctor_get(x_53, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_53, 1); +lean_inc(x_60); +if (lean_is_exclusive(x_53)) { + lean_ctor_release(x_53, 0); + lean_ctor_release(x_53, 1); + x_61 = x_53; +} else { + lean_dec_ref(x_53); + x_61 = lean_box(0); +} +if (lean_is_scalar(x_61)) { + x_62 = lean_alloc_ctor(1, 2, 0); +} else { + x_62 = x_61; +} +lean_ctor_set(x_62, 0, x_59); +lean_ctor_set(x_62, 1, x_60); +return x_62; +} +} +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_63 = lean_ctor_get(x_12, 1); +lean_inc(x_63); +lean_dec(x_12); +x_64 = lean_ctor_get(x_14, 0); +lean_inc(x_64); +x_65 = lean_ctor_get(x_14, 1); +lean_inc(x_65); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_66 = x_14; +} else { + lean_dec_ref(x_14); + x_66 = lean_box(0); +} +x_67 = lean_ctor_get(x_2, 0); +lean_inc(x_67); +lean_dec(x_2); +x_68 = lean_ctor_get(x_67, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_67, 2); +lean_inc(x_69); +lean_dec(x_67); +x_70 = lean_ctor_get(x_69, 8); +lean_inc(x_70); +x_71 = l_System_FilePath_join(x_68, x_70); +x_72 = lean_ctor_get(x_69, 10); +lean_inc(x_72); +lean_dec(x_69); +x_73 = l_System_FilePath_join(x_71, x_72); +x_74 = lean_ctor_get(x_3, 5); +x_75 = l_Lake_nameToStaticLib(x_74); +x_76 = l_System_FilePath_join(x_73, x_75); +x_77 = l_Lake_buildStaticLib(x_76, x_64, x_8, x_13); +lean_dec(x_64); +if (lean_obj_tag(x_77) == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_78 = lean_ctor_get(x_77, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_77, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_77)) { + lean_ctor_release(x_77, 0); + lean_ctor_release(x_77, 1); + x_80 = x_77; +} else { + lean_dec_ref(x_77); + x_80 = lean_box(0); +} +if (lean_is_scalar(x_66)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_66; +} +lean_ctor_set(x_81, 0, x_78); +lean_ctor_set(x_81, 1, x_65); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_63); +if (lean_is_scalar(x_80)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_80; +} +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_79); +return x_83; +} +else +{ +lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_66); +lean_dec(x_65); +lean_dec(x_63); +x_84 = lean_ctor_get(x_77, 0); +lean_inc(x_84); +x_85 = lean_ctor_get(x_77, 1); +lean_inc(x_85); +if (lean_is_exclusive(x_77)) { + lean_ctor_release(x_77, 0); + lean_ctor_release(x_77, 1); + x_86 = x_77; +} else { + lean_dec_ref(x_77); + x_86 = lean_box(0); +} +if (lean_is_scalar(x_86)) { + x_87 = lean_alloc_ctor(1, 2, 0); +} else { + x_87 = x_86; +} +lean_ctor_set(x_87, 0, x_84); +lean_ctor_set(x_87, 1, x_85); +return x_87; +} +} +} +else +{ +uint8_t x_88; +x_88 = !lean_is_exclusive(x_12); +if (x_88 == 0) +{ +lean_object* x_89; lean_object* x_90; uint8_t x_91; +x_89 = lean_ctor_get(x_12, 1); +x_90 = lean_ctor_get(x_12, 0); +lean_dec(x_90); +x_91 = !lean_is_exclusive(x_14); +if (x_91 == 0) +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_92 = lean_ctor_get(x_14, 0); +x_93 = lean_ctor_get(x_14, 1); +x_94 = lean_ctor_get(x_2, 0); +lean_inc(x_94); +lean_dec(x_2); +x_95 = lean_ctor_get(x_94, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_94, 2); +lean_inc(x_96); +lean_dec(x_94); +x_97 = lean_ctor_get(x_96, 8); +lean_inc(x_97); +x_98 = l_System_FilePath_join(x_95, x_97); +x_99 = lean_ctor_get(x_96, 10); +lean_inc(x_99); +lean_dec(x_96); +x_100 = l_System_FilePath_join(x_98, x_99); +x_101 = lean_ctor_get(x_3, 5); +x_102 = l_Lake_nameToStaticLib(x_101); +x_103 = l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1; +x_104 = l_System_FilePath_addExtension(x_102, x_103); +x_105 = l_System_FilePath_join(x_100, x_104); +x_106 = l_Lake_buildStaticLib(x_105, x_92, x_8, x_13); +lean_dec(x_92); +if (lean_obj_tag(x_106) == 0) +{ +uint8_t x_107; +x_107 = !lean_is_exclusive(x_106); +if (x_107 == 0) +{ +lean_object* x_108; +x_108 = lean_ctor_get(x_106, 0); +lean_ctor_set(x_14, 0, x_108); +lean_ctor_set(x_106, 0, x_12); +return x_106; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_106, 0); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_106); +lean_ctor_set(x_14, 0, x_109); +x_111 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_111, 0, x_12); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +else +{ +uint8_t x_112; +lean_free_object(x_14); +lean_dec(x_93); +lean_free_object(x_12); +lean_dec(x_89); +x_112 = !lean_is_exclusive(x_106); +if (x_112 == 0) +{ +return x_106; +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_113 = lean_ctor_get(x_106, 0); +x_114 = lean_ctor_get(x_106, 1); +lean_inc(x_114); +lean_inc(x_113); +lean_dec(x_106); +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 +{ +lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; +x_116 = lean_ctor_get(x_14, 0); +x_117 = lean_ctor_get(x_14, 1); +lean_inc(x_117); +lean_inc(x_116); +lean_dec(x_14); +x_118 = lean_ctor_get(x_2, 0); +lean_inc(x_118); +lean_dec(x_2); +x_119 = lean_ctor_get(x_118, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_118, 2); +lean_inc(x_120); +lean_dec(x_118); +x_121 = lean_ctor_get(x_120, 8); +lean_inc(x_121); +x_122 = l_System_FilePath_join(x_119, x_121); +x_123 = lean_ctor_get(x_120, 10); +lean_inc(x_123); +lean_dec(x_120); +x_124 = l_System_FilePath_join(x_122, x_123); +x_125 = lean_ctor_get(x_3, 5); +x_126 = l_Lake_nameToStaticLib(x_125); +x_127 = l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1; +x_128 = l_System_FilePath_addExtension(x_126, x_127); +x_129 = l_System_FilePath_join(x_124, x_128); +x_130 = l_Lake_buildStaticLib(x_129, x_116, x_8, x_13); +lean_dec(x_116); +if (lean_obj_tag(x_130) == 0) +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_131 = lean_ctor_get(x_130, 0); +lean_inc(x_131); +x_132 = lean_ctor_get(x_130, 1); +lean_inc(x_132); +if (lean_is_exclusive(x_130)) { + lean_ctor_release(x_130, 0); + lean_ctor_release(x_130, 1); + x_133 = x_130; +} else { + lean_dec_ref(x_130); + x_133 = lean_box(0); +} +x_134 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_134, 0, x_131); +lean_ctor_set(x_134, 1, x_117); +lean_ctor_set(x_12, 0, x_134); +if (lean_is_scalar(x_133)) { + x_135 = lean_alloc_ctor(0, 2, 0); +} else { + x_135 = x_133; +} +lean_ctor_set(x_135, 0, x_12); +lean_ctor_set(x_135, 1, x_132); +return x_135; +} +else +{ +lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +lean_dec(x_117); +lean_free_object(x_12); +lean_dec(x_89); +x_136 = lean_ctor_get(x_130, 0); +lean_inc(x_136); +x_137 = lean_ctor_get(x_130, 1); +lean_inc(x_137); +if (lean_is_exclusive(x_130)) { + lean_ctor_release(x_130, 0); + lean_ctor_release(x_130, 1); + x_138 = x_130; +} else { + lean_dec_ref(x_130); + x_138 = lean_box(0); +} +if (lean_is_scalar(x_138)) { + x_139 = lean_alloc_ctor(1, 2, 0); +} else { + x_139 = x_138; +} +lean_ctor_set(x_139, 0, x_136); +lean_ctor_set(x_139, 1, x_137); +return x_139; +} +} +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +x_140 = lean_ctor_get(x_12, 1); +lean_inc(x_140); +lean_dec(x_12); +x_141 = lean_ctor_get(x_14, 0); +lean_inc(x_141); +x_142 = lean_ctor_get(x_14, 1); +lean_inc(x_142); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_143 = x_14; +} else { + lean_dec_ref(x_14); + x_143 = lean_box(0); +} +x_144 = lean_ctor_get(x_2, 0); +lean_inc(x_144); +lean_dec(x_2); +x_145 = lean_ctor_get(x_144, 0); +lean_inc(x_145); +x_146 = lean_ctor_get(x_144, 2); +lean_inc(x_146); +lean_dec(x_144); +x_147 = lean_ctor_get(x_146, 8); +lean_inc(x_147); +x_148 = l_System_FilePath_join(x_145, x_147); +x_149 = lean_ctor_get(x_146, 10); +lean_inc(x_149); +lean_dec(x_146); +x_150 = l_System_FilePath_join(x_148, x_149); +x_151 = lean_ctor_get(x_3, 5); +x_152 = l_Lake_nameToStaticLib(x_151); +x_153 = l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1; +x_154 = l_System_FilePath_addExtension(x_152, x_153); +x_155 = l_System_FilePath_join(x_150, x_154); +x_156 = l_Lake_buildStaticLib(x_155, x_141, x_8, x_13); +lean_dec(x_141); +if (lean_obj_tag(x_156) == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; +x_157 = lean_ctor_get(x_156, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_156, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_156)) { + lean_ctor_release(x_156, 0); + lean_ctor_release(x_156, 1); + x_159 = x_156; +} else { + lean_dec_ref(x_156); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_143)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_143; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_142); +x_161 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_161, 0, x_160); +lean_ctor_set(x_161, 1, x_140); +if (lean_is_scalar(x_159)) { + x_162 = lean_alloc_ctor(0, 2, 0); +} else { + x_162 = x_159; +} +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_158); +return x_162; +} +else +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; +lean_dec(x_143); +lean_dec(x_142); +lean_dec(x_140); +x_163 = lean_ctor_get(x_156, 0); +lean_inc(x_163); +x_164 = lean_ctor_get(x_156, 1); +lean_inc(x_164); +if (lean_is_exclusive(x_156)) { + lean_ctor_release(x_156, 0); + lean_ctor_release(x_156, 1); + x_165 = x_156; +} else { + lean_dec_ref(x_156); + x_165 = lean_box(0); +} +if (lean_is_scalar(x_165)) { + x_166 = lean_alloc_ctor(1, 2, 0); +} else { + x_166 = x_165; +} +lean_ctor_set(x_166, 0, x_163); +lean_ctor_set(x_166, 1, x_164); +return x_166; +} +} +} +} +else +{ +uint8_t x_167; +lean_dec(x_8); +lean_dec(x_2); +x_167 = !lean_is_exclusive(x_12); +if (x_167 == 0) +{ +lean_object* x_168; uint8_t x_169; +x_168 = lean_ctor_get(x_12, 0); +lean_dec(x_168); +x_169 = !lean_is_exclusive(x_14); +if (x_169 == 0) +{ +lean_object* x_170; +x_170 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_170, 0, x_12); +lean_ctor_set(x_170, 1, x_13); +return x_170; +} +else +{ +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; +x_171 = lean_ctor_get(x_14, 0); +x_172 = lean_ctor_get(x_14, 1); +lean_inc(x_172); +lean_inc(x_171); +lean_dec(x_14); +x_173 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_173, 0, x_171); +lean_ctor_set(x_173, 1, x_172); +lean_ctor_set(x_12, 0, x_173); +x_174 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_174, 0, x_12); +lean_ctor_set(x_174, 1, x_13); +return x_174; +} +} +else +{ +lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_175 = lean_ctor_get(x_12, 1); +lean_inc(x_175); +lean_dec(x_12); +x_176 = lean_ctor_get(x_14, 0); +lean_inc(x_176); +x_177 = lean_ctor_get(x_14, 1); +lean_inc(x_177); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_178 = x_14; +} else { + lean_dec_ref(x_14); + x_178 = lean_box(0); +} +if (lean_is_scalar(x_178)) { + x_179 = lean_alloc_ctor(1, 2, 0); +} else { + x_179 = x_178; +} +lean_ctor_set(x_179, 0, x_176); +lean_ctor_set(x_179, 1, x_177); +x_180 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_175); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_13); +return x_181; +} +} +} +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_instMonadBaseIO; +x_2 = l_StateT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_LeanLib_recBuildStatic___closed__1; +x_2 = l_Lake_EStateT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_LeanLib_recBuildStatic___closed__2; +x_2 = l_ReaderT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_LeanLib_recBuildStatic___closed__3; +x_2 = l_ReaderT_instMonad___rarg(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":static", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" (without exports)", 18); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildStatic___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" (with exports)", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; uint8_t x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_9 = l_Lake_LeanLib_recBuildStatic___closed__4; +x_10 = lean_ctor_get(x_9, 1); +lean_inc(x_10); +x_11 = lean_ctor_get(x_5, 0); +lean_inc(x_11); +x_12 = lean_ctor_get_uint8(x_11, sizeof(void*)*1 + 3); +lean_dec(x_11); +x_13 = 2; +x_14 = l_Lake_instDecidableEqVerbosity(x_12, x_13); +x_15 = lean_ctor_get(x_1, 1); +lean_inc(x_15); +x_16 = lean_ctor_get(x_15, 1); +lean_inc(x_16); +x_17 = 1; +x_18 = l_Lean_Name_toString(x_16, x_17); +x_19 = l_Lake_LeanLib_recBuildLean___closed__5; +x_20 = lean_string_append(x_19, x_18); +lean_dec(x_18); +x_21 = l_Lake_LeanLib_recBuildStatic___closed__5; +x_22 = lean_string_append(x_20, x_21); +x_23 = l_Lake_LeanLib_modulesFacetConfig___closed__2; +lean_inc(x_1); +x_24 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_24, 0, x_1); +lean_ctor_set(x_24, 1, x_23); +x_25 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_25, 0, x_24); +lean_closure_set(x_25, 1, lean_box(0)); +x_26 = lean_box(x_2); +x_27 = lean_alloc_closure((void*)(l_Lake_LeanLib_recBuildStatic___lambda__3___boxed), 11, 4); +lean_closure_set(x_27, 0, x_26); +lean_closure_set(x_27, 1, x_1); +lean_closure_set(x_27, 2, x_15); +lean_closure_set(x_27, 3, x_9); +x_28 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___rarg), 6, 5); +lean_closure_set(x_28, 0, x_10); +lean_closure_set(x_28, 1, lean_box(0)); +lean_closure_set(x_28, 2, lean_box(0)); +lean_closure_set(x_28, 3, x_25); +lean_closure_set(x_28, 4, x_27); +if (x_14 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_string_append(x_22, x_19); +x_30 = lean_string_append(x_29, x_19); +x_31 = l_Lake_withRegisterJob___rarg(x_30, x_28, x_3, x_4, x_5, x_6, x_7, x_8); +return x_31; +} +else +{ +if (x_2 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_32 = l_Lake_LeanLib_recBuildStatic___closed__6; +x_33 = lean_string_append(x_22, x_32); +x_34 = lean_string_append(x_33, x_19); +x_35 = l_Lake_withRegisterJob___rarg(x_34, x_28, x_3, x_4, x_5, x_6, x_7, x_8); +return x_35; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = l_Lake_LeanLib_recBuildStatic___closed__7; +x_37 = lean_string_append(x_22, x_36); +x_38 = lean_string_append(x_37, x_19); +x_39 = l_Lake_withRegisterJob___rarg(x_38, x_28, x_3, x_4, x_5, x_6, x_7, x_8); +return x_39; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; lean_object* x_12; +x_11 = lean_unbox(x_1); +lean_dec(x_1); +x_12 = l_Lake_LeanLib_recBuildStatic___lambda__2(x_11, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; lean_object* x_13; +x_12 = lean_unbox(x_1); +lean_dec(x_1); +x_13 = l_Lake_LeanLib_recBuildStatic___lambda__3(x_12, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_3); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildStatic___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +uint8_t x_9; lean_object* x_10; +x_9 = lean_unbox(x_2); +lean_dec(x_2); +x_10 = l_Lake_LeanLib_recBuildStatic(x_1, x_9, x_3, x_4, x_5, x_6, x_7, x_8); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; lean_object* x_9; +x_8 = 0; +x_9 = l_Lake_LeanLib_recBuildStatic(x_1, x_8, x_2, x_3, x_4, x_5, x_6, x_7); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_LeanLib_staticFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_LeanLib_staticFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_LeanLib_staticFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("static", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_staticFacetConfig___closed__3; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacetConfig___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLib_staticFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacetConfig___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_staticFacetConfig___closed__5; +x_2 = l_Lake_LeanLib_staticFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_staticFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_staticFacetConfig___closed__6; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_staticExportFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; lean_object* x_9; +x_8 = 1; +x_9 = l_Lake_LeanLib_recBuildStatic(x_1, x_8, x_2, x_3, x_4, x_5, x_6, x_7); +return x_9; +} +} +static lean_object* _init_l_Lake_LeanLib_staticExportFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_staticFacetConfig___closed__3; +x_2 = l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_staticExportFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLib_staticExportFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_staticExportFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_staticExportFacetConfig___closed__2; +x_2 = l_Lake_LeanLib_staticFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_staticExportFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_staticExportFacetConfig___closed__3; +return x_1; +} +} +LEAN_EXPORT uint8_t l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_4, 2); +x_7 = lean_ctor_get(x_6, 2); +x_8 = lean_ctor_get(x_1, 2); +x_9 = lean_ctor_get(x_8, 2); +x_10 = lean_name_eq(x_7, x_9); +if (x_10 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_12; +x_12 = 1; +return x_12; +} +} +} +} +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_LeanLib_recBuildShared___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint64_t x_7; size_t x_8; lean_object* x_9; uint8_t x_10; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = lean_ctor_get(x_2, 2); +x_6 = lean_ctor_get(x_5, 2); +x_7 = l_Lean_Name_hash___override(x_6); +x_8 = lean_hashset_mk_idx(x_4, x_7); +x_9 = lean_array_uget(x_3, x_8); +x_10 = l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3(x_2, x_9); +lean_dec(x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recBuildShared___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_3, 1); +x_7 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_5); +x_8 = lean_apply_1(x_1, x_5); +x_9 = lean_unbox_uint64(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_7, x_9); +x_11 = lean_array_uget(x_2, x_10); +lean_ctor_set(x_3, 1, x_11); +x_12 = lean_array_uset(x_2, x_10, x_3); +x_2 = x_12; +x_3 = x_6; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint64_t x_18; size_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_14 = lean_ctor_get(x_3, 0); +x_15 = lean_ctor_get(x_3, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_3); +x_16 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_14); +x_17 = lean_apply_1(x_1, x_14); +x_18 = lean_unbox_uint64(x_17); +lean_dec(x_17); +x_19 = lean_hashset_mk_idx(x_16, x_18); +x_20 = lean_array_uget(x_2, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_14); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_array_uset(x_2, x_19, x_21); +x_2 = x_22; +x_3 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_LeanLib_recBuildShared___spec__7___at_Lake_LeanLib_recBuildShared___spec__8(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_array_get_size(x_1); +x_7 = lean_ctor_get(x_4, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 2); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lean_Name_hash___override(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_6, x_9); +x_11 = lean_array_uget(x_1, x_10); +lean_ctor_set(x_2, 1, x_11); +x_12 = lean_array_uset(x_1, x_10, x_2); +x_1 = x_12; +x_2 = x_5; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint64_t x_19; size_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_14 = lean_ctor_get(x_2, 0); +x_15 = lean_ctor_get(x_2, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_2); +x_16 = lean_array_get_size(x_1); +x_17 = lean_ctor_get(x_14, 2); +lean_inc(x_17); +x_18 = lean_ctor_get(x_17, 2); +lean_inc(x_18); +lean_dec(x_17); +x_19 = l_Lean_Name_hash___override(x_18); +lean_dec(x_18); +x_20 = lean_hashset_mk_idx(x_16, x_19); +x_21 = lean_array_uget(x_1, x_20); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_14); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_array_uset(x_1, x_20, x_22); +x_1 = x_23; +x_2 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_LeanLib_recBuildShared___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_array_get_size(x_2); +x_5 = lean_nat_dec_lt(x_1, x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_6 = lean_array_fget(x_2, x_1); +x_7 = lean_box(0); +x_8 = lean_array_fset(x_2, x_1, x_7); +x_9 = l_List_foldl___at_Lake_LeanLib_recBuildShared___spec__7___at_Lake_LeanLib_recBuildShared___spec__8(x_3, x_6); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_8; +x_3 = x_9; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_LeanLib_recBuildShared___spec__5(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_nat_mul(x_3, x_4); +lean_dec(x_3); +x_6 = lean_box(0); +x_7 = lean_mk_array(x_5, x_6); +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_HashSetImp_moveEntries___at_Lake_LeanLib_recBuildShared___spec__6(x_8, x_2, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; +lean_dec(x_3); +x_4 = lean_box(0); +return x_4; +} +else +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_1); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_6 = lean_ctor_get(x_1, 0); +x_7 = lean_ctor_get(x_1, 1); +x_8 = lean_ctor_get(x_6, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 2); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_ctor_get(x_2, 2); +x_11 = lean_ctor_get(x_10, 2); +x_12 = lean_name_eq(x_9, x_11); +lean_dec(x_9); +if (x_12 == 0) +{ +lean_object* x_13; +x_13 = l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9(x_7, x_2, x_3); +lean_ctor_set(x_1, 1, x_13); +return x_1; +} +else +{ +lean_dec(x_6); +lean_ctor_set(x_1, 0, x_3); +return x_1; +} +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_14 = lean_ctor_get(x_1, 0); +x_15 = lean_ctor_get(x_1, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_1); +x_16 = lean_ctor_get(x_14, 2); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 2); +lean_inc(x_17); +lean_dec(x_16); +x_18 = lean_ctor_get(x_2, 2); +x_19 = lean_ctor_get(x_18, 2); +x_20 = lean_name_eq(x_17, x_19); +lean_dec(x_17); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9(x_15, x_2, x_3); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_14); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +else +{ +lean_object* x_23; +lean_dec(x_14); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_3); +lean_ctor_set(x_23, 1, x_15); +return x_23; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_LeanLib_recBuildShared___spec__4(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_1); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; uint8_t x_12; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_array_get_size(x_5); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 2); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lean_Name_hash___override(x_8); +lean_dec(x_8); +lean_inc(x_6); +x_10 = lean_hashset_mk_idx(x_6, x_9); +x_11 = lean_array_uget(x_5, x_10); +x_12 = l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3(x_2, x_11); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; +x_13 = lean_unsigned_to_nat(1u); +x_14 = lean_nat_add(x_4, x_13); +lean_dec(x_4); +x_15 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_15, 0, x_2); +lean_ctor_set(x_15, 1, x_11); +x_16 = lean_array_uset(x_5, x_10, x_15); +x_17 = lean_nat_dec_le(x_14, x_6); +lean_dec(x_6); +if (x_17 == 0) +{ +lean_object* x_18; +lean_free_object(x_1); +x_18 = l_Lean_HashSetImp_expand___at_Lake_LeanLib_recBuildShared___spec__5(x_14, x_16); +return x_18; +} +else +{ +lean_ctor_set(x_1, 1, x_16); +lean_ctor_set(x_1, 0, x_14); +return x_1; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +lean_dec(x_6); +x_19 = lean_box(0); +x_20 = lean_array_uset(x_5, x_10, x_19); +lean_inc(x_2); +x_21 = l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9(x_11, x_2, x_2); +lean_dec(x_2); +x_22 = lean_array_uset(x_20, x_10, x_21); +lean_ctor_set(x_1, 1, x_22); +return x_1; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint64_t x_28; size_t x_29; lean_object* x_30; uint8_t x_31; +x_23 = lean_ctor_get(x_1, 0); +x_24 = lean_ctor_get(x_1, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_1); +x_25 = lean_array_get_size(x_24); +x_26 = lean_ctor_get(x_2, 2); +lean_inc(x_26); +x_27 = lean_ctor_get(x_26, 2); +lean_inc(x_27); +lean_dec(x_26); +x_28 = l_Lean_Name_hash___override(x_27); +lean_dec(x_27); +lean_inc(x_25); +x_29 = lean_hashset_mk_idx(x_25, x_28); +x_30 = lean_array_uget(x_24, x_29); +x_31 = l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3(x_2, x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_32 = lean_unsigned_to_nat(1u); +x_33 = lean_nat_add(x_23, x_32); +lean_dec(x_23); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_2); +lean_ctor_set(x_34, 1, x_30); +x_35 = lean_array_uset(x_24, x_29, x_34); +x_36 = lean_nat_dec_le(x_33, x_25); +lean_dec(x_25); +if (x_36 == 0) +{ +lean_object* x_37; +x_37 = l_Lean_HashSetImp_expand___at_Lake_LeanLib_recBuildShared___spec__5(x_33, x_35); +return x_37; +} +else +{ +lean_object* x_38; +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_33); +lean_ctor_set(x_38, 1, x_35); +return x_38; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_25); +x_39 = lean_box(0); +x_40 = lean_array_uset(x_24, x_29, x_39); +lean_inc(x_2); +x_41 = l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9(x_30, x_2, x_2); +lean_dec(x_2); +x_42 = lean_array_uset(x_40, x_29, x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_23); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instHashablePackage___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instBEqPackage___boxed), 2, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = l_Lean_HashSetImp_contains___at_Lake_LeanLib_recBuildShared___spec__2(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +lean_inc(x_2); +x_6 = lean_array_push(x_5, x_2); +x_7 = l_Lean_HashSetImp_insert___at_Lake_LeanLib_recBuildShared___spec__4(x_3, x_2); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +return x_8; +} +else +{ +lean_dec(x_3); +lean_dec(x_2); +return x_1; +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanLib_recBuildShared___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_3, 0); +x_5 = lean_ctor_get(x_3, 1); +x_6 = lean_ctor_get(x_3, 2); +x_7 = lean_ctor_get(x_3, 3); +lean_inc(x_1); +x_8 = l_Lean_RBNode_fold___at_Lake_LeanLib_recBuildShared___spec__10(x_1, x_2, x_4); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_5); +lean_ctor_set(x_9, 2, x_6); +x_10 = lean_array_push(x_8, x_9); +x_2 = x_10; +x_3 = x_7; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__11(size_t x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = lean_usize_dec_lt(x_2, x_1); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_3); +lean_ctor_set(x_11, 1, x_7); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_14 = lean_array_uget(x_3, x_2); +x_15 = lean_unsigned_to_nat(0u); +x_16 = lean_array_uset(x_3, x_2, x_15); +x_17 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_17, 0, x_14); +lean_inc(x_4); +lean_inc(x_6); +lean_inc(x_5); +x_18 = lean_apply_6(x_4, x_17, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +if (lean_obj_tag(x_20) == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; size_t x_25; size_t x_26; lean_object* x_27; +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_20, 1); +lean_inc(x_24); +lean_dec(x_20); +x_25 = 1; +x_26 = lean_usize_add(x_2, x_25); +x_27 = lean_array_uset(x_16, x_2, x_23); +x_2 = x_26; +x_3 = x_27; +x_7 = x_24; +x_8 = x_22; +x_9 = x_21; +goto _start; +} +else +{ +uint8_t x_29; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_29 = !lean_is_exclusive(x_18); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_18, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_19); +if (x_31 == 0) +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_19, 0); +lean_dec(x_32); +x_33 = !lean_is_exclusive(x_20); +if (x_33 == 0) +{ +return x_18; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_20, 0); +x_35 = lean_ctor_get(x_20, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_20); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +lean_ctor_set(x_19, 0, x_36); +return x_18; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_37 = lean_ctor_get(x_19, 1); +lean_inc(x_37); +lean_dec(x_19); +x_38 = lean_ctor_get(x_20, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_20, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_40 = x_20; +} else { + lean_dec_ref(x_20); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +lean_ctor_set(x_18, 0, x_42); +return x_18; +} +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_43 = lean_ctor_get(x_18, 1); +lean_inc(x_43); +lean_dec(x_18); +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_45 = x_19; +} else { + lean_dec_ref(x_19); + x_45 = lean_box(0); +} +x_46 = lean_ctor_get(x_20, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_20, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_48 = x_20; +} else { + lean_dec_ref(x_20); + x_48 = lean_box(0); +} +if (lean_is_scalar(x_48)) { + x_49 = lean_alloc_ctor(1, 2, 0); +} else { + x_49 = x_48; +} +lean_ctor_set(x_49, 0, x_46); +lean_ctor_set(x_49, 1, x_47); +if (lean_is_scalar(x_45)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_45; +} +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_44); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_43); +return x_51; +} +} +} +else +{ +uint8_t x_52; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_52 = !lean_is_exclusive(x_18); +if (x_52 == 0) +{ +return x_18; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_18, 0); +x_54 = lean_ctor_get(x_18, 1); +lean_inc(x_54); +lean_inc(x_53); +lean_dec(x_18); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +return x_55; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__12(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; +x_11 = lean_usize_dec_eq(x_2, x_3); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; size_t x_18; lean_object* x_19; +x_12 = lean_array_uget(x_1, x_2); +x_13 = lean_ctor_get(x_12, 10); +lean_inc(x_13); +x_14 = 0; +x_15 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_16 = l_Lean_RBNode_fold___at_Lake_LeanLib_recBuildShared___spec__10(x_12, x_15, x_13); +lean_dec(x_13); +x_17 = lean_array_get_size(x_16); +x_18 = lean_usize_of_nat(x_17); +lean_dec(x_17); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +x_19 = l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__11(x_18, x_14, x_16, x_5, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; size_t x_27; size_t x_28; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_21, 1); +lean_inc(x_25); +lean_dec(x_21); +x_26 = l_Array_append___rarg(x_4, x_24); +lean_dec(x_24); +x_27 = 1; +x_28 = lean_usize_add(x_2, x_27); +x_2 = x_28; +x_4 = x_26; +x_8 = x_25; +x_9 = x_23; +x_10 = x_22; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_30 = !lean_is_exclusive(x_19); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_19, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_20); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_20, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_21); +if (x_34 == 0) +{ +return x_19; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_21, 0); +x_36 = lean_ctor_get(x_21, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_21); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_20, 0, x_37); +return x_19; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_20, 1); +lean_inc(x_38); +lean_dec(x_20); +x_39 = lean_ctor_get(x_21, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_21, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_41 = x_21; +} else { + lean_dec_ref(x_21); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +lean_ctor_set(x_19, 0, x_43); +return x_19; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +lean_dec(x_19); +x_45 = lean_ctor_get(x_20, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_46 = x_20; +} else { + lean_dec_ref(x_20); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_21, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_21, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_49 = x_21; +} else { + lean_dec_ref(x_21); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +if (lean_is_scalar(x_46)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_46; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_45); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_53 = !lean_is_exclusive(x_19); +if (x_53 == 0) +{ +return x_19; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_19, 0); +x_55 = lean_ctor_get(x_19, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_19); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_4); +lean_ctor_set(x_57, 1, x_8); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_9); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_10); +return x_59; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__13(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; size_t x_10; size_t x_11; +x_6 = lean_array_uget(x_1, x_2); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1(x_4, x_8); +x_10 = 1; +x_11 = lean_usize_add(x_2, x_10); +x_2 = x_11; +x_4 = x_9; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__14(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; +x_11 = lean_usize_dec_lt(x_3, x_2); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_4); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_10); +return x_14; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_15 = lean_array_uget(x_4, x_3); +x_16 = lean_unsigned_to_nat(0u); +x_17 = lean_array_uset(x_4, x_3, x_16); +lean_inc(x_1); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_1); +lean_ctor_set(x_18, 1, x_15); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_19 = lean_apply_6(x_5, x_18, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; size_t x_26; size_t x_27; lean_object* x_28; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_21, 1); +lean_inc(x_25); +lean_dec(x_21); +x_26 = 1; +x_27 = lean_usize_add(x_3, x_26); +x_28 = lean_array_uset(x_17, x_3, x_24); +x_3 = x_27; +x_4 = x_28; +x_8 = x_25; +x_9 = x_23; +x_10 = x_22; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_17); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_30 = !lean_is_exclusive(x_19); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_19, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_20); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_20, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_21); +if (x_34 == 0) +{ +return x_19; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_21, 0); +x_36 = lean_ctor_get(x_21, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_21); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_20, 0, x_37); +return x_19; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_20, 1); +lean_inc(x_38); +lean_dec(x_20); +x_39 = lean_ctor_get(x_21, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_21, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_41 = x_21; +} else { + lean_dec_ref(x_21); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +lean_ctor_set(x_19, 0, x_43); +return x_19; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +lean_dec(x_19); +x_45 = lean_ctor_get(x_20, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_46 = x_20; +} else { + lean_dec_ref(x_20); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_21, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_21, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_49 = x_21; +} else { + lean_dec_ref(x_21); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +if (lean_is_scalar(x_46)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_46; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_45); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_17); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_53 = !lean_is_exclusive(x_19); +if (x_53 == 0) +{ +return x_19; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_19, 0); +x_55 = lean_ctor_get(x_19, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_19); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__15(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; +x_11 = lean_usize_dec_eq(x_2, x_3); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; size_t x_20; size_t x_21; lean_object* x_22; +x_12 = lean_array_uget(x_1, x_2); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_13, 1); +lean_inc(x_14); +lean_dec(x_13); +x_15 = lean_ctor_get(x_14, 8); +lean_inc(x_15); +lean_dec(x_14); +x_16 = 1; +x_17 = lean_box(x_16); +x_18 = lean_apply_1(x_15, x_17); +x_19 = lean_array_get_size(x_18); +x_20 = lean_usize_of_nat(x_19); +lean_dec(x_19); +x_21 = 0; +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +x_22 = l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__14(x_12, x_20, x_21, x_18, x_5, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_23, 0); +lean_inc(x_24); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; size_t x_30; size_t x_31; +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +lean_dec(x_22); +x_26 = lean_ctor_get(x_23, 1); +lean_inc(x_26); +lean_dec(x_23); +x_27 = lean_ctor_get(x_24, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_24, 1); +lean_inc(x_28); +lean_dec(x_24); +x_29 = l_Array_append___rarg(x_4, x_27); +lean_dec(x_27); +x_30 = 1; +x_31 = lean_usize_add(x_2, x_30); +x_2 = x_31; +x_4 = x_29; +x_8 = x_28; +x_9 = x_26; +x_10 = x_25; +goto _start; +} +else +{ +uint8_t x_33; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_33 = !lean_is_exclusive(x_22); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = lean_ctor_get(x_22, 0); +lean_dec(x_34); +x_35 = !lean_is_exclusive(x_23); +if (x_35 == 0) +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_23, 0); +lean_dec(x_36); +x_37 = !lean_is_exclusive(x_24); +if (x_37 == 0) +{ +return x_22; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_24, 0); +x_39 = lean_ctor_get(x_24, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_24); +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +lean_ctor_set(x_23, 0, x_40); +return x_22; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_41 = lean_ctor_get(x_23, 1); +lean_inc(x_41); +lean_dec(x_23); +x_42 = lean_ctor_get(x_24, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_24, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_44 = x_24; +} else { + lean_dec_ref(x_24); + x_44 = lean_box(0); +} +if (lean_is_scalar(x_44)) { + x_45 = lean_alloc_ctor(1, 2, 0); +} else { + x_45 = x_44; +} +lean_ctor_set(x_45, 0, x_42); +lean_ctor_set(x_45, 1, x_43); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_41); +lean_ctor_set(x_22, 0, x_46); +return x_22; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_47 = lean_ctor_get(x_22, 1); +lean_inc(x_47); +lean_dec(x_22); +x_48 = lean_ctor_get(x_23, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + lean_ctor_release(x_23, 1); + x_49 = x_23; +} else { + lean_dec_ref(x_23); + x_49 = lean_box(0); +} +x_50 = lean_ctor_get(x_24, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_24, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_52 = x_24; +} else { + lean_dec_ref(x_24); + x_52 = lean_box(0); +} +if (lean_is_scalar(x_52)) { + x_53 = lean_alloc_ctor(1, 2, 0); +} else { + x_53 = x_52; +} +lean_ctor_set(x_53, 0, x_50); +lean_ctor_set(x_53, 1, x_51); +if (lean_is_scalar(x_49)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_49; +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_48); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_47); +return x_55; +} +} +} +else +{ +uint8_t x_56; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_56 = !lean_is_exclusive(x_22); +if (x_56 == 0) +{ +return x_22; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_57 = lean_ctor_get(x_22, 0); +x_58 = lean_ctor_get(x_22, 1); +lean_inc(x_58); +lean_inc(x_57); +lean_dec(x_22); +x_59 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_59, 0, x_57); +lean_ctor_set(x_59, 1, x_58); +return x_59; +} +} +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_4); +lean_ctor_set(x_60, 1, x_8); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_9); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_10); +return x_62; +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanLib_recBuildShared___spec__16___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_3); +x_9 = lean_apply_6(x_1, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = lean_apply_7(x_2, x_14, x_3, x_4, x_5, x_15, x_13, x_12); +return x_16; +} +else +{ +uint8_t x_17; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_17 = !lean_is_exclusive(x_9); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_ctor_get(x_9, 0); +lean_dec(x_18); +x_19 = !lean_is_exclusive(x_10); +if (x_19 == 0) +{ +lean_object* x_20; uint8_t x_21; +x_20 = lean_ctor_get(x_10, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_11); +if (x_21 == 0) +{ +return x_9; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_11); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +lean_ctor_set(x_10, 0, x_24); +return x_9; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 1); +lean_inc(x_25); +lean_dec(x_10); +x_26 = lean_ctor_get(x_11, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_11, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_28 = x_11; +} else { + lean_dec_ref(x_11); + x_28 = lean_box(0); +} +if (lean_is_scalar(x_28)) { + x_29 = lean_alloc_ctor(1, 2, 0); +} else { + x_29 = x_28; +} +lean_ctor_set(x_29, 0, x_26); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 1); +lean_inc(x_32); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_33 = x_10; +} else { + lean_dec_ref(x_10); + x_33 = lean_box(0); +} +x_34 = lean_ctor_get(x_11, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_11, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_36 = x_11; +} else { + lean_dec_ref(x_11); + x_36 = lean_box(0); +} +if (lean_is_scalar(x_36)) { + x_37 = lean_alloc_ctor(1, 2, 0); +} else { + x_37 = x_36; +} +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_35); +if (lean_is_scalar(x_33)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_33; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_32); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_31); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +return x_9; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_9, 0); +x_42 = lean_ctor_get(x_9, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_9); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_LeanLib_recBuildShared___spec__16(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_LeanLib_recBuildShared___spec__16___rarg), 8, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildShared___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_185; lean_object* x_186; uint8_t x_187; +x_185 = lean_array_get_size(x_3); +x_186 = lean_unsigned_to_nat(0u); +x_187 = lean_nat_dec_lt(x_186, x_185); +if (x_187 == 0) +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; +lean_dec(x_185); +x_188 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_189 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_189, 0, x_188); +lean_ctor_set(x_189, 1, x_7); +x_190 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_190, 0, x_189); +lean_ctor_set(x_190, 1, x_8); +x_10 = x_190; +x_11 = x_9; +goto block_184; +} +else +{ +uint8_t x_191; +x_191 = lean_nat_dec_le(x_185, x_185); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; +lean_dec(x_185); +x_192 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +x_193 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_193, 0, x_192); +lean_ctor_set(x_193, 1, x_7); +x_194 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_194, 0, x_193); +lean_ctor_set(x_194, 1, x_8); +x_10 = x_194; +x_11 = x_9; +goto block_184; +} +else +{ +size_t x_195; size_t x_196; lean_object* x_197; lean_object* x_198; +x_195 = 0; +x_196 = lean_usize_of_nat(x_185); +lean_dec(x_185); +x_197 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +x_198 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__15(x_3, x_195, x_196, x_197, x_4, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_198) == 0) +{ +lean_object* x_199; lean_object* x_200; +x_199 = lean_ctor_get(x_198, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_198, 1); +lean_inc(x_200); +lean_dec(x_198); +x_10 = x_199; +x_11 = x_200; +goto block_184; +} +else +{ +uint8_t x_201; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +x_201 = !lean_is_exclusive(x_198); +if (x_201 == 0) +{ +return x_198; +} +else +{ +lean_object* x_202; lean_object* x_203; lean_object* x_204; +x_202 = lean_ctor_get(x_198, 0); +x_203 = lean_ctor_get(x_198, 1); +lean_inc(x_203); +lean_inc(x_202); +lean_dec(x_198); +x_204 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_204, 0, x_202); +lean_ctor_set(x_204, 1, x_203); +return x_204; +} +} +} +} +block_184: +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_137; lean_object* x_138; uint8_t x_139; lean_object* x_140; +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_14 = x_10; +} else { + lean_dec_ref(x_10); + x_14 = lean_box(0); +} +x_15 = lean_ctor_get(x_12, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_12, 1); +lean_inc(x_16); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_17 = x_12; +} else { + lean_dec_ref(x_12); + x_17 = lean_box(0); +} +x_137 = lean_array_get_size(x_3); +x_138 = lean_unsigned_to_nat(0u); +x_139 = lean_nat_dec_lt(x_138, x_137); +if (x_139 == 0) +{ +lean_object* x_162; +lean_dec(x_137); +x_162 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_140 = x_162; +goto block_161; +} +else +{ +uint8_t x_163; +x_163 = lean_nat_dec_le(x_137, x_137); +if (x_163 == 0) +{ +lean_object* x_164; +lean_dec(x_137); +x_164 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_140 = x_164; +goto block_161; +} +else +{ +size_t x_165; size_t x_166; lean_object* x_167; lean_object* x_168; +x_165 = 0; +x_166 = lean_usize_of_nat(x_137); +lean_dec(x_137); +x_167 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_168 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__13(x_3, x_165, x_166, x_167); +x_140 = x_168; +goto block_161; +} +} +block_136: +{ +lean_object* x_20; +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +if (lean_obj_tag(x_20) == 0) +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_18); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; +x_22 = lean_ctor_get(x_18, 1); +x_23 = lean_ctor_get(x_18, 0); +lean_dec(x_23); +x_24 = !lean_is_exclusive(x_20); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_25 = lean_ctor_get(x_20, 0); +x_26 = lean_ctor_get(x_20, 1); +x_27 = lean_ctor_get(x_1, 0); +lean_inc(x_27); +lean_dec(x_1); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_27, 2); +lean_inc(x_29); +lean_dec(x_27); +x_30 = lean_ctor_get(x_29, 8); +lean_inc(x_30); +x_31 = l_System_FilePath_join(x_28, x_30); +x_32 = lean_ctor_get(x_29, 10); +lean_inc(x_32); +x_33 = l_System_FilePath_join(x_31, x_32); +x_34 = lean_ctor_get(x_2, 5); +x_35 = l_Lake_nameToSharedLib(x_34); +x_36 = l_System_FilePath_join(x_33, x_35); +x_37 = l_Array_append___rarg(x_15, x_25); +lean_dec(x_25); +x_38 = lean_ctor_get(x_29, 1); +lean_inc(x_38); +lean_dec(x_29); +x_39 = lean_ctor_get(x_38, 7); +lean_inc(x_39); +x_40 = lean_ctor_get(x_2, 0); +x_41 = lean_ctor_get(x_40, 7); +x_42 = l_Array_append___rarg(x_39, x_41); +x_43 = lean_ctor_get(x_38, 6); +lean_inc(x_43); +lean_dec(x_38); +x_44 = lean_ctor_get(x_40, 6); +x_45 = l_Array_append___rarg(x_43, x_44); +x_46 = l_Lake_buildLeanSharedLib(x_36, x_37, x_42, x_45, x_6, x_19); +lean_dec(x_37); +if (lean_obj_tag(x_46) == 0) +{ +uint8_t x_47; +x_47 = !lean_is_exclusive(x_46); +if (x_47 == 0) +{ +lean_object* x_48; +x_48 = lean_ctor_get(x_46, 0); +lean_ctor_set(x_20, 0, x_48); +lean_ctor_set(x_46, 0, x_18); +return x_46; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_46, 0); +x_50 = lean_ctor_get(x_46, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_46); +lean_ctor_set(x_20, 0, x_49); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_18); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +else +{ +uint8_t x_52; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_18); +lean_dec(x_22); +x_52 = !lean_is_exclusive(x_46); +if (x_52 == 0) +{ +return x_46; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_46, 0); +x_54 = lean_ctor_get(x_46, 1); +lean_inc(x_54); +lean_inc(x_53); +lean_dec(x_46); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +return x_55; +} +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_56 = lean_ctor_get(x_20, 0); +x_57 = lean_ctor_get(x_20, 1); +lean_inc(x_57); +lean_inc(x_56); +lean_dec(x_20); +x_58 = lean_ctor_get(x_1, 0); +lean_inc(x_58); +lean_dec(x_1); +x_59 = lean_ctor_get(x_58, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_58, 2); +lean_inc(x_60); +lean_dec(x_58); +x_61 = lean_ctor_get(x_60, 8); +lean_inc(x_61); +x_62 = l_System_FilePath_join(x_59, x_61); +x_63 = lean_ctor_get(x_60, 10); +lean_inc(x_63); +x_64 = l_System_FilePath_join(x_62, x_63); +x_65 = lean_ctor_get(x_2, 5); +x_66 = l_Lake_nameToSharedLib(x_65); +x_67 = l_System_FilePath_join(x_64, x_66); +x_68 = l_Array_append___rarg(x_15, x_56); +lean_dec(x_56); +x_69 = lean_ctor_get(x_60, 1); +lean_inc(x_69); +lean_dec(x_60); +x_70 = lean_ctor_get(x_69, 7); +lean_inc(x_70); +x_71 = lean_ctor_get(x_2, 0); +x_72 = lean_ctor_get(x_71, 7); +x_73 = l_Array_append___rarg(x_70, x_72); +x_74 = lean_ctor_get(x_69, 6); +lean_inc(x_74); +lean_dec(x_69); +x_75 = lean_ctor_get(x_71, 6); +x_76 = l_Array_append___rarg(x_74, x_75); +x_77 = l_Lake_buildLeanSharedLib(x_67, x_68, x_73, x_76, x_6, x_19); +lean_dec(x_68); +if (lean_obj_tag(x_77) == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_78 = lean_ctor_get(x_77, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_77, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_77)) { + lean_ctor_release(x_77, 0); + lean_ctor_release(x_77, 1); + x_80 = x_77; +} else { + lean_dec_ref(x_77); + x_80 = lean_box(0); +} +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_78); +lean_ctor_set(x_81, 1, x_57); +lean_ctor_set(x_18, 0, x_81); +if (lean_is_scalar(x_80)) { + x_82 = lean_alloc_ctor(0, 2, 0); +} else { + x_82 = x_80; +} +lean_ctor_set(x_82, 0, x_18); +lean_ctor_set(x_82, 1, x_79); +return x_82; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +lean_dec(x_57); +lean_free_object(x_18); +lean_dec(x_22); +x_83 = lean_ctor_get(x_77, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_77, 1); +lean_inc(x_84); +if (lean_is_exclusive(x_77)) { + lean_ctor_release(x_77, 0); + lean_ctor_release(x_77, 1); + x_85 = x_77; +} else { + lean_dec_ref(x_77); + x_85 = lean_box(0); +} +if (lean_is_scalar(x_85)) { + x_86 = lean_alloc_ctor(1, 2, 0); +} else { + x_86 = x_85; +} +lean_ctor_set(x_86, 0, x_83); +lean_ctor_set(x_86, 1, x_84); +return x_86; +} +} +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; +x_87 = lean_ctor_get(x_18, 1); +lean_inc(x_87); +lean_dec(x_18); +x_88 = lean_ctor_get(x_20, 0); +lean_inc(x_88); +x_89 = lean_ctor_get(x_20, 1); +lean_inc(x_89); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_90 = x_20; +} else { + lean_dec_ref(x_20); + x_90 = lean_box(0); +} +x_91 = lean_ctor_get(x_1, 0); +lean_inc(x_91); +lean_dec(x_1); +x_92 = lean_ctor_get(x_91, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_91, 2); +lean_inc(x_93); +lean_dec(x_91); +x_94 = lean_ctor_get(x_93, 8); +lean_inc(x_94); +x_95 = l_System_FilePath_join(x_92, x_94); +x_96 = lean_ctor_get(x_93, 10); +lean_inc(x_96); +x_97 = l_System_FilePath_join(x_95, x_96); +x_98 = lean_ctor_get(x_2, 5); +x_99 = l_Lake_nameToSharedLib(x_98); +x_100 = l_System_FilePath_join(x_97, x_99); +x_101 = l_Array_append___rarg(x_15, x_88); +lean_dec(x_88); +x_102 = lean_ctor_get(x_93, 1); +lean_inc(x_102); +lean_dec(x_93); +x_103 = lean_ctor_get(x_102, 7); +lean_inc(x_103); +x_104 = lean_ctor_get(x_2, 0); +x_105 = lean_ctor_get(x_104, 7); +x_106 = l_Array_append___rarg(x_103, x_105); +x_107 = lean_ctor_get(x_102, 6); +lean_inc(x_107); +lean_dec(x_102); +x_108 = lean_ctor_get(x_104, 6); +x_109 = l_Array_append___rarg(x_107, x_108); +x_110 = l_Lake_buildLeanSharedLib(x_100, x_101, x_106, x_109, x_6, x_19); +lean_dec(x_101); +if (lean_obj_tag(x_110) == 0) +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_111 = lean_ctor_get(x_110, 0); +lean_inc(x_111); +x_112 = lean_ctor_get(x_110, 1); +lean_inc(x_112); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_113 = x_110; +} else { + lean_dec_ref(x_110); + x_113 = lean_box(0); +} +if (lean_is_scalar(x_90)) { + x_114 = lean_alloc_ctor(0, 2, 0); +} else { + x_114 = x_90; +} +lean_ctor_set(x_114, 0, x_111); +lean_ctor_set(x_114, 1, x_89); +x_115 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_115, 0, x_114); +lean_ctor_set(x_115, 1, x_87); +if (lean_is_scalar(x_113)) { + x_116 = lean_alloc_ctor(0, 2, 0); +} else { + x_116 = x_113; +} +lean_ctor_set(x_116, 0, x_115); +lean_ctor_set(x_116, 1, x_112); +return x_116; +} +else +{ +lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; +lean_dec(x_90); +lean_dec(x_89); +lean_dec(x_87); +x_117 = lean_ctor_get(x_110, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_110, 1); +lean_inc(x_118); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_119 = x_110; +} else { + lean_dec_ref(x_110); + x_119 = lean_box(0); +} +if (lean_is_scalar(x_119)) { + x_120 = lean_alloc_ctor(1, 2, 0); +} else { + x_120 = x_119; +} +lean_ctor_set(x_120, 0, x_117); +lean_ctor_set(x_120, 1, x_118); +return x_120; +} +} +} +else +{ +uint8_t x_121; +lean_dec(x_15); +lean_dec(x_6); +lean_dec(x_1); +x_121 = !lean_is_exclusive(x_18); +if (x_121 == 0) +{ +lean_object* x_122; uint8_t x_123; +x_122 = lean_ctor_get(x_18, 0); +lean_dec(x_122); +x_123 = !lean_is_exclusive(x_20); +if (x_123 == 0) +{ +lean_object* x_124; +x_124 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_124, 0, x_18); +lean_ctor_set(x_124, 1, x_19); +return x_124; +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_125 = lean_ctor_get(x_20, 0); +x_126 = lean_ctor_get(x_20, 1); +lean_inc(x_126); +lean_inc(x_125); +lean_dec(x_20); +x_127 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_127, 0, x_125); +lean_ctor_set(x_127, 1, x_126); +lean_ctor_set(x_18, 0, x_127); +x_128 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_128, 0, x_18); +lean_ctor_set(x_128, 1, x_19); +return x_128; +} +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_129 = lean_ctor_get(x_18, 1); +lean_inc(x_129); +lean_dec(x_18); +x_130 = lean_ctor_get(x_20, 0); +lean_inc(x_130); +x_131 = lean_ctor_get(x_20, 1); +lean_inc(x_131); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_132 = x_20; +} else { + lean_dec_ref(x_20); + x_132 = lean_box(0); +} +if (lean_is_scalar(x_132)) { + x_133 = lean_alloc_ctor(1, 2, 0); +} else { + x_133 = x_132; +} +lean_ctor_set(x_133, 0, x_130); +lean_ctor_set(x_133, 1, x_131); +x_134 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_134, 0, x_133); +lean_ctor_set(x_134, 1, x_129); +x_135 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_19); +return x_135; +} +} +} +block_161: +{ +lean_object* x_141; lean_object* x_142; uint8_t x_143; +x_141 = lean_ctor_get(x_140, 1); +lean_inc(x_141); +lean_dec(x_140); +x_142 = lean_array_get_size(x_141); +x_143 = lean_nat_dec_lt(x_138, x_142); +if (x_143 == 0) +{ +lean_object* x_144; lean_object* x_145; lean_object* x_146; +lean_dec(x_142); +lean_dec(x_141); +lean_dec(x_5); +lean_dec(x_4); +x_144 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +if (lean_is_scalar(x_17)) { + x_145 = lean_alloc_ctor(0, 2, 0); +} else { + x_145 = x_17; +} +lean_ctor_set(x_145, 0, x_144); +lean_ctor_set(x_145, 1, x_16); +if (lean_is_scalar(x_14)) { + x_146 = lean_alloc_ctor(0, 2, 0); +} else { + x_146 = x_14; +} +lean_ctor_set(x_146, 0, x_145); +lean_ctor_set(x_146, 1, x_13); +x_18 = x_146; +x_19 = x_11; +goto block_136; +} +else +{ +uint8_t x_147; +x_147 = lean_nat_dec_le(x_142, x_142); +if (x_147 == 0) +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; +lean_dec(x_142); +lean_dec(x_141); +lean_dec(x_5); +lean_dec(x_4); +x_148 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +if (lean_is_scalar(x_17)) { + x_149 = lean_alloc_ctor(0, 2, 0); +} else { + x_149 = x_17; +} +lean_ctor_set(x_149, 0, x_148); +lean_ctor_set(x_149, 1, x_16); +if (lean_is_scalar(x_14)) { + x_150 = lean_alloc_ctor(0, 2, 0); +} else { + x_150 = x_14; +} +lean_ctor_set(x_150, 0, x_149); +lean_ctor_set(x_150, 1, x_13); +x_18 = x_150; +x_19 = x_11; +goto block_136; +} +else +{ +size_t x_151; size_t x_152; lean_object* x_153; lean_object* x_154; +lean_dec(x_17); +lean_dec(x_14); +x_151 = 0; +x_152 = lean_usize_of_nat(x_142); +lean_dec(x_142); +x_153 = l_Lake_LeanLib_recCollectLocalModules___closed__1; +lean_inc(x_6); +x_154 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__12(x_141, x_151, x_152, x_153, x_4, x_5, x_6, x_16, x_13, x_11); +lean_dec(x_141); +if (lean_obj_tag(x_154) == 0) +{ +lean_object* x_155; lean_object* x_156; +x_155 = lean_ctor_get(x_154, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_154, 1); +lean_inc(x_156); +lean_dec(x_154); +x_18 = x_155; +x_19 = x_156; +goto block_136; +} +else +{ +uint8_t x_157; +lean_dec(x_15); +lean_dec(x_6); +lean_dec(x_1); +x_157 = !lean_is_exclusive(x_154); +if (x_157 == 0) +{ +return x_154; +} +else +{ +lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_158 = lean_ctor_get(x_154, 0); +x_159 = lean_ctor_get(x_154, 1); +lean_inc(x_159); +lean_inc(x_158); +lean_dec(x_154); +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; +} +} +} +} +} +} +else +{ +uint8_t x_169; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +x_169 = !lean_is_exclusive(x_10); +if (x_169 == 0) +{ +lean_object* x_170; uint8_t x_171; +x_170 = lean_ctor_get(x_10, 0); +lean_dec(x_170); +x_171 = !lean_is_exclusive(x_12); +if (x_171 == 0) +{ +lean_object* x_172; +x_172 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_172, 0, x_10); +lean_ctor_set(x_172, 1, x_11); +return x_172; +} +else +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; +x_173 = lean_ctor_get(x_12, 0); +x_174 = lean_ctor_get(x_12, 1); +lean_inc(x_174); +lean_inc(x_173); +lean_dec(x_12); +x_175 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_175, 0, x_173); +lean_ctor_set(x_175, 1, x_174); +lean_ctor_set(x_10, 0, x_175); +x_176 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_176, 0, x_10); +lean_ctor_set(x_176, 1, x_11); +return x_176; +} +} +else +{ +lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_177 = lean_ctor_get(x_10, 1); +lean_inc(x_177); +lean_dec(x_10); +x_178 = lean_ctor_get(x_12, 0); +lean_inc(x_178); +x_179 = lean_ctor_get(x_12, 1); +lean_inc(x_179); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_180 = x_12; +} else { + lean_dec_ref(x_12); + x_180 = lean_box(0); +} +if (lean_is_scalar(x_180)) { + x_181 = lean_alloc_ctor(1, 2, 0); +} else { + x_181 = x_180; +} +lean_ctor_set(x_181, 0, x_178); +lean_ctor_set(x_181, 1, x_179); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_177); +x_183 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_11); +return x_183; +} +} +} +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildShared___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":shared", 7); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildShared(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +x_10 = 1; +x_11 = l_Lean_Name_toString(x_9, x_10); +x_12 = l_Lake_LeanLib_recBuildLean___closed__5; +x_13 = lean_string_append(x_12, x_11); +lean_dec(x_11); +x_14 = l_Lake_LeanLib_recBuildShared___closed__1; +x_15 = lean_string_append(x_13, x_14); +x_16 = l_Lake_LeanLib_modulesFacetConfig___closed__2; +lean_inc(x_1); +x_17 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_17, 0, x_1); +lean_ctor_set(x_17, 1, x_16); +x_18 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_18, 0, x_17); +lean_closure_set(x_18, 1, lean_box(0)); +x_19 = lean_alloc_closure((void*)(l_Lake_LeanLib_recBuildShared___lambda__1___boxed), 9, 2); +lean_closure_set(x_19, 0, x_1); +lean_closure_set(x_19, 1, x_8); +x_20 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_LeanLib_recBuildShared___spec__16___rarg), 8, 2); +lean_closure_set(x_20, 0, x_18); +lean_closure_set(x_20, 1, x_19); +x_21 = l_Lake_withRegisterJob___rarg(x_15, x_20, x_2, x_3, x_4, x_5, x_6, x_7); +return x_21; +} +} +LEAN_EXPORT lean_object* l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_List_elem___at_Lake_LeanLib_recBuildShared___spec__3(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_LeanLib_recBuildShared___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lean_HashSetImp_contains___at_Lake_LeanLib_recBuildShared___spec__2(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_replace___at_Lake_LeanLib_recBuildShared___spec__9(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_LeanLib_recBuildShared___spec__10___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_fold___at_Lake_LeanLib_recBuildShared___spec__10(x_1, x_2, x_3); +lean_dec(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__11___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; size_t x_11; lean_object* x_12; +x_10 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__11(x_10, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__12___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__12(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__13___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__13(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__14___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_mapMUnsafe_map___at_Lake_LeanLib_recBuildShared___spec__14(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__15___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildShared___spec__15(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildShared___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_LeanLib_recBuildShared___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_3); +lean_dec(x_2); +return x_10; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("shared", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_sharedFacetConfig___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLib_recBuildShared), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_sharedFacetConfig___closed__3; +x_2 = l_Lake_LeanLib_staticFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_sharedFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_sharedFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; +x_12 = lean_usize_dec_eq(x_3, x_4); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_array_uget(x_2, x_3); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_1); +x_14 = l_Lake_Package_fetchTargetJob(x_1, x_13, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; size_t x_22; size_t x_23; +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_16, 1); +lean_inc(x_20); +lean_dec(x_16); +x_21 = l_Lake_BuildJob_mix___rarg(x_5, x_19); +x_22 = 1; +x_23 = lean_usize_add(x_3, x_22); +x_3 = x_23; +x_5 = x_21; +x_9 = x_20; +x_10 = x_18; +x_11 = x_17; +goto _start; +} +else +{ +uint8_t x_25; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_25 = !lean_is_exclusive(x_14); +if (x_25 == 0) +{ +lean_object* x_26; uint8_t x_27; +x_26 = lean_ctor_get(x_14, 0); +lean_dec(x_26); +x_27 = !lean_is_exclusive(x_15); +if (x_27 == 0) +{ +lean_object* x_28; uint8_t x_29; +x_28 = lean_ctor_get(x_15, 0); +lean_dec(x_28); +x_29 = !lean_is_exclusive(x_16); +if (x_29 == 0) +{ +return x_14; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_16, 0); +x_31 = lean_ctor_get(x_16, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_16); +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_31); +lean_ctor_set(x_15, 0, x_32); +return x_14; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_33 = lean_ctor_get(x_15, 1); +lean_inc(x_33); +lean_dec(x_15); +x_34 = lean_ctor_get(x_16, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_16, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_36 = x_16; +} else { + lean_dec_ref(x_16); + x_36 = lean_box(0); +} +if (lean_is_scalar(x_36)) { + x_37 = lean_alloc_ctor(1, 2, 0); +} else { + x_37 = x_36; +} +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_35); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_33); +lean_ctor_set(x_14, 0, x_38); +return x_14; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_39 = lean_ctor_get(x_14, 1); +lean_inc(x_39); +lean_dec(x_14); +x_40 = lean_ctor_get(x_15, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_41 = x_15; +} else { + lean_dec_ref(x_15); + x_41 = lean_box(0); +} +x_42 = lean_ctor_get(x_16, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_16, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_44 = x_16; +} else { + lean_dec_ref(x_16); + x_44 = lean_box(0); +} +if (lean_is_scalar(x_44)) { + x_45 = lean_alloc_ctor(1, 2, 0); +} else { + x_45 = x_44; +} +lean_ctor_set(x_45, 0, x_42); +lean_ctor_set(x_45, 1, x_43); +if (lean_is_scalar(x_41)) { + x_46 = lean_alloc_ctor(0, 2, 0); +} else { + x_46 = x_41; +} +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_40); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_39); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_48 = !lean_is_exclusive(x_14); +if (x_48 == 0) +{ +return x_14; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_14, 0); +x_50 = lean_ctor_get(x_14, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_14); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_5); +lean_ctor_set(x_52, 1, x_9); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_10); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_11); +return x_54; +} +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildExtraDepTargets___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("extraDep", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_recBuildExtraDepTargets___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_recBuildExtraDepTargets___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_recBuildExtraDepTargets(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_1); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_9 = lean_ctor_get(x_1, 0); +x_10 = lean_ctor_get(x_1, 1); +x_11 = l_Lake_LeanLib_recBuildExtraDepTargets___closed__2; +lean_inc(x_9); +lean_ctor_set_tag(x_1, 1); +lean_ctor_set(x_1, 1, x_11); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +x_12 = lean_apply_6(x_2, x_1, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_12); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_16 = lean_ctor_get(x_12, 1); +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_13); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_19 = lean_ctor_get(x_13, 1); +x_20 = lean_ctor_get(x_13, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_14); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; +x_22 = lean_ctor_get(x_14, 0); +x_23 = lean_ctor_get(x_14, 1); +x_24 = lean_ctor_get(x_10, 6); +lean_inc(x_24); +lean_dec(x_10); +x_25 = lean_array_get_size(x_24); +x_26 = lean_unsigned_to_nat(0u); +x_27 = lean_nat_dec_lt(x_26, x_25); +if (x_27 == 0) +{ +lean_dec(x_25); +lean_dec(x_24); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_12; +} +else +{ +uint8_t x_28; +x_28 = lean_nat_dec_le(x_25, x_25); +if (x_28 == 0) +{ +lean_dec(x_25); +lean_dec(x_24); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_12; +} +else +{ +size_t x_29; size_t x_30; lean_object* x_31; +lean_free_object(x_14); +lean_free_object(x_13); +lean_free_object(x_12); +x_29 = 0; +x_30 = lean_usize_of_nat(x_25); +lean_dec(x_25); +x_31 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1(x_9, x_24, x_29, x_30, x_22, x_2, x_3, x_4, x_23, x_19, x_16); +lean_dec(x_24); +return x_31; +} +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_32 = lean_ctor_get(x_14, 0); +x_33 = lean_ctor_get(x_14, 1); +lean_inc(x_33); +lean_inc(x_32); +lean_dec(x_14); +x_34 = lean_ctor_get(x_10, 6); +lean_inc(x_34); +lean_dec(x_10); +x_35 = lean_array_get_size(x_34); +x_36 = lean_unsigned_to_nat(0u); +x_37 = lean_nat_dec_lt(x_36, x_35); +if (x_37 == 0) +{ +lean_object* x_38; +lean_dec(x_35); +lean_dec(x_34); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_32); +lean_ctor_set(x_38, 1, x_33); +lean_ctor_set(x_13, 0, x_38); +return x_12; +} +else +{ +uint8_t x_39; +x_39 = lean_nat_dec_le(x_35, x_35); +if (x_39 == 0) +{ +lean_object* x_40; +lean_dec(x_35); +lean_dec(x_34); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_32); +lean_ctor_set(x_40, 1, x_33); +lean_ctor_set(x_13, 0, x_40); +return x_12; +} +else +{ +size_t x_41; size_t x_42; lean_object* x_43; +lean_free_object(x_13); +lean_free_object(x_12); +x_41 = 0; +x_42 = lean_usize_of_nat(x_35); +lean_dec(x_35); +x_43 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1(x_9, x_34, x_41, x_42, x_32, x_2, x_3, x_4, x_33, x_19, x_16); +lean_dec(x_34); +return x_43; +} +} +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; +x_44 = lean_ctor_get(x_13, 1); +lean_inc(x_44); +lean_dec(x_13); +x_45 = lean_ctor_get(x_14, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_14, 1); +lean_inc(x_46); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_47 = x_14; +} else { + lean_dec_ref(x_14); + x_47 = lean_box(0); +} +x_48 = lean_ctor_get(x_10, 6); +lean_inc(x_48); +lean_dec(x_10); +x_49 = lean_array_get_size(x_48); +x_50 = lean_unsigned_to_nat(0u); +x_51 = lean_nat_dec_lt(x_50, x_49); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; +lean_dec(x_49); +lean_dec(x_48); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +if (lean_is_scalar(x_47)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_47; +} +lean_ctor_set(x_52, 0, x_45); +lean_ctor_set(x_52, 1, x_46); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_44); +lean_ctor_set(x_12, 0, x_53); +return x_12; +} +else +{ +uint8_t x_54; +x_54 = lean_nat_dec_le(x_49, x_49); +if (x_54 == 0) +{ +lean_object* x_55; lean_object* x_56; +lean_dec(x_49); +lean_dec(x_48); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +if (lean_is_scalar(x_47)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_47; +} +lean_ctor_set(x_55, 0, x_45); +lean_ctor_set(x_55, 1, x_46); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_44); +lean_ctor_set(x_12, 0, x_56); +return x_12; +} +else +{ +size_t x_57; size_t x_58; lean_object* x_59; +lean_dec(x_47); +lean_free_object(x_12); +x_57 = 0; +x_58 = lean_usize_of_nat(x_49); +lean_dec(x_49); +x_59 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1(x_9, x_48, x_57, x_58, x_45, x_2, x_3, x_4, x_46, x_44, x_16); +lean_dec(x_48); +return x_59; +} +} +} +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; +x_60 = lean_ctor_get(x_12, 1); +lean_inc(x_60); +lean_dec(x_12); +x_61 = lean_ctor_get(x_13, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_62 = x_13; +} else { + lean_dec_ref(x_13); + x_62 = lean_box(0); +} +x_63 = lean_ctor_get(x_14, 0); +lean_inc(x_63); +x_64 = lean_ctor_get(x_14, 1); +lean_inc(x_64); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_65 = x_14; +} else { + lean_dec_ref(x_14); + x_65 = lean_box(0); +} +x_66 = lean_ctor_get(x_10, 6); +lean_inc(x_66); +lean_dec(x_10); +x_67 = lean_array_get_size(x_66); +x_68 = lean_unsigned_to_nat(0u); +x_69 = lean_nat_dec_lt(x_68, x_67); +if (x_69 == 0) +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +lean_dec(x_67); +lean_dec(x_66); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +if (lean_is_scalar(x_65)) { + x_70 = lean_alloc_ctor(0, 2, 0); +} else { + x_70 = x_65; +} +lean_ctor_set(x_70, 0, x_63); +lean_ctor_set(x_70, 1, x_64); +if (lean_is_scalar(x_62)) { + x_71 = lean_alloc_ctor(0, 2, 0); +} else { + x_71 = x_62; +} +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_61); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_60); +return x_72; +} +else +{ +uint8_t x_73; +x_73 = lean_nat_dec_le(x_67, x_67); +if (x_73 == 0) +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +if (lean_is_scalar(x_65)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_65; +} +lean_ctor_set(x_74, 0, x_63); +lean_ctor_set(x_74, 1, x_64); +if (lean_is_scalar(x_62)) { + x_75 = lean_alloc_ctor(0, 2, 0); +} else { + x_75 = x_62; +} +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_61); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_60); +return x_76; +} +else +{ +size_t x_77; size_t x_78; lean_object* x_79; +lean_dec(x_65); +lean_dec(x_62); +x_77 = 0; +x_78 = lean_usize_of_nat(x_67); +lean_dec(x_67); +x_79 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1(x_9, x_66, x_77, x_78, x_63, x_2, x_3, x_4, x_64, x_61, x_60); +lean_dec(x_66); +return x_79; +} +} +} +} +else +{ +uint8_t x_80; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_80 = !lean_is_exclusive(x_12); +if (x_80 == 0) +{ +lean_object* x_81; uint8_t x_82; +x_81 = lean_ctor_get(x_12, 0); +lean_dec(x_81); +x_82 = !lean_is_exclusive(x_13); +if (x_82 == 0) +{ +lean_object* x_83; uint8_t x_84; +x_83 = lean_ctor_get(x_13, 0); +lean_dec(x_83); +x_84 = !lean_is_exclusive(x_14); +if (x_84 == 0) +{ +return x_12; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_14, 0); +x_86 = lean_ctor_get(x_14, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_14); +x_87 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set(x_87, 1, x_86); +lean_ctor_set(x_13, 0, x_87); +return x_12; +} +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_88 = lean_ctor_get(x_13, 1); +lean_inc(x_88); +lean_dec(x_13); +x_89 = lean_ctor_get(x_14, 0); +lean_inc(x_89); +x_90 = lean_ctor_get(x_14, 1); +lean_inc(x_90); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_91 = x_14; +} else { + lean_dec_ref(x_14); + x_91 = lean_box(0); +} +if (lean_is_scalar(x_91)) { + x_92 = lean_alloc_ctor(1, 2, 0); +} else { + x_92 = x_91; +} +lean_ctor_set(x_92, 0, x_89); +lean_ctor_set(x_92, 1, x_90); +x_93 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_88); +lean_ctor_set(x_12, 0, x_93); +return x_12; +} +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; +x_94 = lean_ctor_get(x_12, 1); +lean_inc(x_94); +lean_dec(x_12); +x_95 = lean_ctor_get(x_13, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_96 = x_13; +} else { + lean_dec_ref(x_13); + x_96 = lean_box(0); +} +x_97 = lean_ctor_get(x_14, 0); +lean_inc(x_97); +x_98 = lean_ctor_get(x_14, 1); +lean_inc(x_98); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_99 = x_14; +} else { + lean_dec_ref(x_14); + x_99 = lean_box(0); +} +if (lean_is_scalar(x_99)) { + x_100 = lean_alloc_ctor(1, 2, 0); +} else { + x_100 = x_99; +} +lean_ctor_set(x_100, 0, x_97); +lean_ctor_set(x_100, 1, x_98); +if (lean_is_scalar(x_96)) { + x_101 = lean_alloc_ctor(0, 2, 0); +} else { + x_101 = x_96; +} +lean_ctor_set(x_101, 0, x_100); +lean_ctor_set(x_101, 1, x_95); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_94); +return x_102; +} +} +} +else +{ +uint8_t x_103; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_103 = !lean_is_exclusive(x_12); +if (x_103 == 0) +{ +return x_12; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_12, 0); +x_105 = lean_ctor_get(x_12, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_12); +x_106 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_106, 0, x_104); +lean_ctor_set(x_106, 1, x_105); +return x_106; +} +} +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_107 = lean_ctor_get(x_1, 0); +x_108 = lean_ctor_get(x_1, 1); +lean_inc(x_108); +lean_inc(x_107); +lean_dec(x_1); +x_109 = l_Lake_LeanLib_recBuildExtraDepTargets___closed__2; +lean_inc(x_107); +x_110 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_110, 0, x_107); +lean_ctor_set(x_110, 1, x_109); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +x_111 = lean_apply_6(x_2, x_110, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_111) == 0) +{ +lean_object* x_112; lean_object* x_113; +x_112 = lean_ctor_get(x_111, 0); +lean_inc(x_112); +x_113 = lean_ctor_get(x_112, 0); +lean_inc(x_113); +if (lean_obj_tag(x_113) == 0) +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; +x_114 = lean_ctor_get(x_111, 1); +lean_inc(x_114); +if (lean_is_exclusive(x_111)) { + lean_ctor_release(x_111, 0); + lean_ctor_release(x_111, 1); + x_115 = x_111; +} else { + lean_dec_ref(x_111); + x_115 = lean_box(0); +} +x_116 = lean_ctor_get(x_112, 1); +lean_inc(x_116); +if (lean_is_exclusive(x_112)) { + lean_ctor_release(x_112, 0); + lean_ctor_release(x_112, 1); + x_117 = x_112; +} else { + lean_dec_ref(x_112); + x_117 = lean_box(0); +} +x_118 = lean_ctor_get(x_113, 0); +lean_inc(x_118); +x_119 = lean_ctor_get(x_113, 1); +lean_inc(x_119); +if (lean_is_exclusive(x_113)) { + lean_ctor_release(x_113, 0); + lean_ctor_release(x_113, 1); + x_120 = x_113; +} else { + lean_dec_ref(x_113); + x_120 = lean_box(0); +} +x_121 = lean_ctor_get(x_108, 6); +lean_inc(x_121); +lean_dec(x_108); +x_122 = lean_array_get_size(x_121); +x_123 = lean_unsigned_to_nat(0u); +x_124 = lean_nat_dec_lt(x_123, x_122); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; +lean_dec(x_122); +lean_dec(x_121); +lean_dec(x_107); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +if (lean_is_scalar(x_120)) { + x_125 = lean_alloc_ctor(0, 2, 0); +} else { + x_125 = x_120; +} +lean_ctor_set(x_125, 0, x_118); +lean_ctor_set(x_125, 1, x_119); +if (lean_is_scalar(x_117)) { + x_126 = lean_alloc_ctor(0, 2, 0); +} else { + x_126 = x_117; +} +lean_ctor_set(x_126, 0, x_125); +lean_ctor_set(x_126, 1, x_116); +if (lean_is_scalar(x_115)) { + x_127 = lean_alloc_ctor(0, 2, 0); +} else { + x_127 = x_115; +} +lean_ctor_set(x_127, 0, x_126); +lean_ctor_set(x_127, 1, x_114); +return x_127; +} +else +{ +uint8_t x_128; +x_128 = lean_nat_dec_le(x_122, x_122); +if (x_128 == 0) +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; +lean_dec(x_122); +lean_dec(x_121); +lean_dec(x_107); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +if (lean_is_scalar(x_120)) { + x_129 = lean_alloc_ctor(0, 2, 0); +} else { + x_129 = x_120; +} +lean_ctor_set(x_129, 0, x_118); +lean_ctor_set(x_129, 1, x_119); +if (lean_is_scalar(x_117)) { + x_130 = lean_alloc_ctor(0, 2, 0); +} else { + x_130 = x_117; +} +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_116); +if (lean_is_scalar(x_115)) { + x_131 = lean_alloc_ctor(0, 2, 0); +} else { + x_131 = x_115; +} +lean_ctor_set(x_131, 0, x_130); +lean_ctor_set(x_131, 1, x_114); +return x_131; +} +else +{ +size_t x_132; size_t x_133; lean_object* x_134; +lean_dec(x_120); +lean_dec(x_117); +lean_dec(x_115); +x_132 = 0; +x_133 = lean_usize_of_nat(x_122); +lean_dec(x_122); +x_134 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1(x_107, x_121, x_132, x_133, x_118, x_2, x_3, x_4, x_119, x_116, x_114); +lean_dec(x_121); +return x_134; +} +} +} +else +{ +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; +lean_dec(x_108); +lean_dec(x_107); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_135 = lean_ctor_get(x_111, 1); +lean_inc(x_135); +if (lean_is_exclusive(x_111)) { + lean_ctor_release(x_111, 0); + lean_ctor_release(x_111, 1); + x_136 = x_111; +} else { + lean_dec_ref(x_111); + x_136 = lean_box(0); +} +x_137 = lean_ctor_get(x_112, 1); +lean_inc(x_137); +if (lean_is_exclusive(x_112)) { + lean_ctor_release(x_112, 0); + lean_ctor_release(x_112, 1); + x_138 = x_112; +} else { + lean_dec_ref(x_112); + x_138 = lean_box(0); +} +x_139 = lean_ctor_get(x_113, 0); +lean_inc(x_139); +x_140 = lean_ctor_get(x_113, 1); +lean_inc(x_140); +if (lean_is_exclusive(x_113)) { + lean_ctor_release(x_113, 0); + lean_ctor_release(x_113, 1); + x_141 = x_113; +} else { + lean_dec_ref(x_113); + x_141 = lean_box(0); +} +if (lean_is_scalar(x_141)) { + x_142 = lean_alloc_ctor(1, 2, 0); +} else { + x_142 = x_141; +} +lean_ctor_set(x_142, 0, x_139); +lean_ctor_set(x_142, 1, x_140); +if (lean_is_scalar(x_138)) { + x_143 = lean_alloc_ctor(0, 2, 0); +} else { + x_143 = x_138; +} +lean_ctor_set(x_143, 0, x_142); +lean_ctor_set(x_143, 1, x_137); +if (lean_is_scalar(x_136)) { + x_144 = lean_alloc_ctor(0, 2, 0); +} else { + x_144 = x_136; +} +lean_ctor_set(x_144, 0, x_143); +lean_ctor_set(x_144, 1, x_135); +return x_144; +} +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; +lean_dec(x_108); +lean_dec(x_107); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_145 = lean_ctor_get(x_111, 0); +lean_inc(x_145); +x_146 = lean_ctor_get(x_111, 1); +lean_inc(x_146); +if (lean_is_exclusive(x_111)) { + lean_ctor_release(x_111, 0); + lean_ctor_release(x_111, 1); + x_147 = x_111; +} else { + lean_dec_ref(x_111); + x_147 = lean_box(0); +} +if (lean_is_scalar(x_147)) { + x_148 = lean_alloc_ctor(1, 2, 0); +} else { + x_148 = x_147; +} +lean_ctor_set(x_148, 0, x_145); +lean_ctor_set(x_148, 1, x_146); +return x_148; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildExtraDepTargets___spec__1(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +return x_14; +} +} +static lean_object* _init_l_Lake_LeanLib_extraDepFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLib_recBuildExtraDepTargets), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLib_extraDepFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_LeanLib_extraDepFacetConfig___closed__1; +x_2 = l_Lake_LeanLib_leanArtsFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_LeanLib_extraDepFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_LeanLib_extraDepFacetConfig___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_initLibraryFacetConfigs___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = lean_box(0); +x_2 = l_Lake_LeanLib_modulesFacetConfig___closed__2; +x_3 = l_Lake_LeanLib_modulesFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addLibraryFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initLibraryFacetConfigs___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initLibraryFacetConfigs___closed__1; +x_2 = l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__2; +x_3 = l_Lake_LeanLib_leanArtsFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addLibraryFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initLibraryFacetConfigs___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initLibraryFacetConfigs___closed__2; +x_2 = l_Lake_LeanLib_staticFacetConfig___closed__4; +x_3 = l_Lake_LeanLib_staticFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addLibraryFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initLibraryFacetConfigs___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initLibraryFacetConfigs___closed__3; +x_2 = l_Lake_LeanLib_staticExportFacetConfig___closed__1; +x_3 = l_Lake_LeanLib_staticExportFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addLibraryFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initLibraryFacetConfigs___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initLibraryFacetConfigs___closed__4; +x_2 = l_Lake_LeanLib_sharedFacetConfig___closed__2; +x_3 = l_Lake_LeanLib_sharedFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addLibraryFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initLibraryFacetConfigs___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initLibraryFacetConfigs___closed__5; +x_2 = l_Lake_LeanLib_recBuildExtraDepTargets___closed__2; +x_3 = l_Lake_LeanLib_extraDepFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addLibraryFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initLibraryFacetConfigs() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_initLibraryFacetConfigs___closed__6; +return x_1; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Common(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Targets(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Library(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Common(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Targets(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_LeanLib_recCollectLocalModules_go___closed__1 = _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_recCollectLocalModules_go___closed__1); +l_Lake_LeanLib_recCollectLocalModules_go___closed__2 = _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_recCollectLocalModules_go___closed__2); +l_Lake_LeanLib_recCollectLocalModules_go___closed__3 = _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_recCollectLocalModules_go___closed__3); +l_Lake_LeanLib_recCollectLocalModules_go___closed__4 = _init_l_Lake_LeanLib_recCollectLocalModules_go___closed__4(); +lean_mark_persistent(l_Lake_LeanLib_recCollectLocalModules_go___closed__4); +l_Lake_LeanLib_recCollectLocalModules___closed__1 = _init_l_Lake_LeanLib_recCollectLocalModules___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_recCollectLocalModules___closed__1); +l_Lake_LeanLib_recCollectLocalModules___closed__2 = _init_l_Lake_LeanLib_recCollectLocalModules___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_recCollectLocalModules___closed__2); +l_Lake_LeanLib_recCollectLocalModules___closed__3 = _init_l_Lake_LeanLib_recCollectLocalModules___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_recCollectLocalModules___closed__3); +l_Lake_LeanLib_modulesFacetConfig___closed__1 = _init_l_Lake_LeanLib_modulesFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacetConfig___closed__1); +l_Lake_LeanLib_modulesFacetConfig___closed__2 = _init_l_Lake_LeanLib_modulesFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacetConfig___closed__2); +l_Lake_LeanLib_modulesFacetConfig___closed__3 = _init_l_Lake_LeanLib_modulesFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacetConfig___closed__3); +l_Lake_LeanLib_modulesFacetConfig___closed__4 = _init_l_Lake_LeanLib_modulesFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacetConfig___closed__4); +l_Lake_LeanLib_modulesFacetConfig = _init_l_Lake_LeanLib_modulesFacetConfig(); +lean_mark_persistent(l_Lake_LeanLib_modulesFacetConfig); +l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__1 = _init_l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__1(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__1); +l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__2 = _init_l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__2(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_LeanLib_recBuildLean___spec__1___closed__2); +l_Lake_LeanLib_recBuildLean___closed__1 = _init_l_Lake_LeanLib_recBuildLean___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_recBuildLean___closed__1); +l_Lake_LeanLib_recBuildLean___closed__2 = _init_l_Lake_LeanLib_recBuildLean___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_recBuildLean___closed__2); +l_Lake_LeanLib_recBuildLean___closed__3 = _init_l_Lake_LeanLib_recBuildLean___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_recBuildLean___closed__3); +l_Lake_LeanLib_recBuildLean___closed__4 = _init_l_Lake_LeanLib_recBuildLean___closed__4(); +lean_mark_persistent(l_Lake_LeanLib_recBuildLean___closed__4); +l_Lake_LeanLib_recBuildLean___closed__5 = _init_l_Lake_LeanLib_recBuildLean___closed__5(); +lean_mark_persistent(l_Lake_LeanLib_recBuildLean___closed__5); +l_Lake_LeanLib_recBuildLean___closed__6 = _init_l_Lake_LeanLib_recBuildLean___closed__6(); +lean_mark_persistent(l_Lake_LeanLib_recBuildLean___closed__6); +l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__1 = _init_l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__1(); +lean_mark_persistent(l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__1); +l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2 = _init_l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2(); +lean_mark_persistent(l_Functor_discard___at_Lake_LeanLib_leanArtsFacetConfig___spec__1___closed__2); +l_Lake_LeanLib_leanArtsFacetConfig___closed__1 = _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_leanArtsFacetConfig___closed__1); +l_Lake_LeanLib_leanArtsFacetConfig___closed__2 = _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_leanArtsFacetConfig___closed__2); +l_Lake_LeanLib_leanArtsFacetConfig___closed__3 = _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_leanArtsFacetConfig___closed__3); +l_Lake_LeanLib_leanArtsFacetConfig___closed__4 = _init_l_Lake_LeanLib_leanArtsFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_LeanLib_leanArtsFacetConfig___closed__4); +l_Lake_LeanLib_leanArtsFacetConfig = _init_l_Lake_LeanLib_leanArtsFacetConfig(); +lean_mark_persistent(l_Lake_LeanLib_leanArtsFacetConfig); +l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1 = _init_l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___lambda__3___closed__1); +l_Lake_LeanLib_recBuildStatic___closed__1 = _init_l_Lake_LeanLib_recBuildStatic___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___closed__1); +l_Lake_LeanLib_recBuildStatic___closed__2 = _init_l_Lake_LeanLib_recBuildStatic___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___closed__2); +l_Lake_LeanLib_recBuildStatic___closed__3 = _init_l_Lake_LeanLib_recBuildStatic___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___closed__3); +l_Lake_LeanLib_recBuildStatic___closed__4 = _init_l_Lake_LeanLib_recBuildStatic___closed__4(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___closed__4); +l_Lake_LeanLib_recBuildStatic___closed__5 = _init_l_Lake_LeanLib_recBuildStatic___closed__5(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___closed__5); +l_Lake_LeanLib_recBuildStatic___closed__6 = _init_l_Lake_LeanLib_recBuildStatic___closed__6(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___closed__6); +l_Lake_LeanLib_recBuildStatic___closed__7 = _init_l_Lake_LeanLib_recBuildStatic___closed__7(); +lean_mark_persistent(l_Lake_LeanLib_recBuildStatic___closed__7); +l_Lake_LeanLib_staticFacetConfig___closed__1 = _init_l_Lake_LeanLib_staticFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_staticFacetConfig___closed__1); +l_Lake_LeanLib_staticFacetConfig___closed__2 = _init_l_Lake_LeanLib_staticFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_staticFacetConfig___closed__2); +l_Lake_LeanLib_staticFacetConfig___closed__3 = _init_l_Lake_LeanLib_staticFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_staticFacetConfig___closed__3); +l_Lake_LeanLib_staticFacetConfig___closed__4 = _init_l_Lake_LeanLib_staticFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_LeanLib_staticFacetConfig___closed__4); +l_Lake_LeanLib_staticFacetConfig___closed__5 = _init_l_Lake_LeanLib_staticFacetConfig___closed__5(); +lean_mark_persistent(l_Lake_LeanLib_staticFacetConfig___closed__5); +l_Lake_LeanLib_staticFacetConfig___closed__6 = _init_l_Lake_LeanLib_staticFacetConfig___closed__6(); +lean_mark_persistent(l_Lake_LeanLib_staticFacetConfig___closed__6); +l_Lake_LeanLib_staticFacetConfig = _init_l_Lake_LeanLib_staticFacetConfig(); +lean_mark_persistent(l_Lake_LeanLib_staticFacetConfig); +l_Lake_LeanLib_staticExportFacetConfig___closed__1 = _init_l_Lake_LeanLib_staticExportFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_staticExportFacetConfig___closed__1); +l_Lake_LeanLib_staticExportFacetConfig___closed__2 = _init_l_Lake_LeanLib_staticExportFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_staticExportFacetConfig___closed__2); +l_Lake_LeanLib_staticExportFacetConfig___closed__3 = _init_l_Lake_LeanLib_staticExportFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_staticExportFacetConfig___closed__3); +l_Lake_LeanLib_staticExportFacetConfig = _init_l_Lake_LeanLib_staticExportFacetConfig(); +lean_mark_persistent(l_Lake_LeanLib_staticExportFacetConfig); +l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__1 = _init_l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__1(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__1); +l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__2 = _init_l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__2(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_LeanLib_recBuildShared___spec__1___closed__2); +l_Lake_LeanLib_recBuildShared___closed__1 = _init_l_Lake_LeanLib_recBuildShared___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_recBuildShared___closed__1); +l_Lake_LeanLib_sharedFacetConfig___closed__1 = _init_l_Lake_LeanLib_sharedFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacetConfig___closed__1); +l_Lake_LeanLib_sharedFacetConfig___closed__2 = _init_l_Lake_LeanLib_sharedFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacetConfig___closed__2); +l_Lake_LeanLib_sharedFacetConfig___closed__3 = _init_l_Lake_LeanLib_sharedFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacetConfig___closed__3); +l_Lake_LeanLib_sharedFacetConfig___closed__4 = _init_l_Lake_LeanLib_sharedFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacetConfig___closed__4); +l_Lake_LeanLib_sharedFacetConfig = _init_l_Lake_LeanLib_sharedFacetConfig(); +lean_mark_persistent(l_Lake_LeanLib_sharedFacetConfig); +l_Lake_LeanLib_recBuildExtraDepTargets___closed__1 = _init_l_Lake_LeanLib_recBuildExtraDepTargets___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_recBuildExtraDepTargets___closed__1); +l_Lake_LeanLib_recBuildExtraDepTargets___closed__2 = _init_l_Lake_LeanLib_recBuildExtraDepTargets___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_recBuildExtraDepTargets___closed__2); +l_Lake_LeanLib_extraDepFacetConfig___closed__1 = _init_l_Lake_LeanLib_extraDepFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_LeanLib_extraDepFacetConfig___closed__1); +l_Lake_LeanLib_extraDepFacetConfig___closed__2 = _init_l_Lake_LeanLib_extraDepFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_LeanLib_extraDepFacetConfig___closed__2); +l_Lake_LeanLib_extraDepFacetConfig = _init_l_Lake_LeanLib_extraDepFacetConfig(); +lean_mark_persistent(l_Lake_LeanLib_extraDepFacetConfig); +l_Lake_initLibraryFacetConfigs___closed__1 = _init_l_Lake_initLibraryFacetConfigs___closed__1(); +lean_mark_persistent(l_Lake_initLibraryFacetConfigs___closed__1); +l_Lake_initLibraryFacetConfigs___closed__2 = _init_l_Lake_initLibraryFacetConfigs___closed__2(); +lean_mark_persistent(l_Lake_initLibraryFacetConfigs___closed__2); +l_Lake_initLibraryFacetConfigs___closed__3 = _init_l_Lake_initLibraryFacetConfigs___closed__3(); +lean_mark_persistent(l_Lake_initLibraryFacetConfigs___closed__3); +l_Lake_initLibraryFacetConfigs___closed__4 = _init_l_Lake_initLibraryFacetConfigs___closed__4(); +lean_mark_persistent(l_Lake_initLibraryFacetConfigs___closed__4); +l_Lake_initLibraryFacetConfigs___closed__5 = _init_l_Lake_initLibraryFacetConfigs___closed__5(); +lean_mark_persistent(l_Lake_initLibraryFacetConfigs___closed__5); +l_Lake_initLibraryFacetConfigs___closed__6 = _init_l_Lake_initLibraryFacetConfigs___closed__6(); +lean_mark_persistent(l_Lake_initLibraryFacetConfigs___closed__6); +l_Lake_initLibraryFacetConfigs = _init_l_Lake_initLibraryFacetConfigs(); +lean_mark_persistent(l_Lake_initLibraryFacetConfigs); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Module.c b/stage0/stdlib/Lake/Build/Module.c new file mode 100644 index 0000000000..797407dc2e --- /dev/null +++ b/stage0/stdlib/Lake/Build/Module.c @@ -0,0 +1,34041 @@ +// Lean compiler output +// Module: Lake.Build.Module +// Imports: Init Lake.Util.OrdHashSet Lake.Util.List Lean.Elab.ParseImportsFast Lake.Build.Common +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__1; +static lean_object* l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__1; +extern lean_object* l_Lake_MTime_instOrd; +static lean_object* l_Lake_Module_transImportsFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_Module_recParseImports___spec__6(lean_object*, lean_object*); +lean_object* l_Lake_compileO(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Module_bcFile_x3f(lean_object*); +static lean_object* l_Lake_Module_recBuildLeanCToOExport___closed__4; +uint8_t lean_uint32_to_uint8(uint32_t); +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(lean_object*, lean_object*); +static lean_object* l_Lake_Module_dynlibFacetConfig___closed__2; +static lean_object* l_Lake_Module_leanArtsFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig; +LEAN_EXPORT uint8_t l_List_elem___at_Lake_Module_recParseImports___spec__4(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__2; +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__3___boxed(lean_object**); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__2; +static lean_object* l_Lake_Module_coNoExportFacetConfig___closed__2; +extern lean_object* l_Lake_instOrdBuildType; +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_collectImportsAux___spec__2(lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__5(lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_System_FilePath_join(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_nameToSharedLib(lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__13; +static lean_object* l_Lake_Module_recBuildLean___lambda__5___closed__1; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static uint8_t l_Lake_Module_clearOutputHashes___closed__3; +lean_object* l_Lake_instBEqModule___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recParseImports(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_oFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToONoExport___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint64_t lean_uint64_mix_hash(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanBcToO(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_get_set_stdout(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +size_t lean_hashset_mk_idx(lean_object*, uint64_t); +static lean_object* l_Lake_Module_depsFacetConfig___closed__1; +lean_object* l_Lake_compileSharedLib(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_transImportsFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__4; +lean_object* l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +uint64_t l_Lake_computeArrayHash___at_Lake_buildO___spec__1(lean_object*); +static lean_object* l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__3(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_leanArtsFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_bcFacetConfig___closed__2; +static lean_object* l_Lake_Module_clearOutputHashes___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_depsFacetConfig___closed__5; +lean_object* lean_mk_array(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_transImportsFacetConfig; +static lean_object* l_Lake_Module_ileanFacetConfig___closed__2; +uint8_t lean_usize_dec_eq(size_t, size_t); +static lean_object* l_Lake_initModuleFacetConfigs___closed__10; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3(size_t, size_t, lean_object*); +static lean_object* l_Lake_Module_recBuildLeanCToONoExport___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recParseImports___spec__8(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__8; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___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_EXPORT lean_object* l_Lake_Module_bcFacetConfig___elambda__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_coFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4(size_t, size_t, lean_object*); +lean_object* lean_array_fget(lean_object*, lean_object*); +lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__1; +static lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +static lean_object* l_Lake_Module_oExportFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15(lean_object*, size_t, size_t, lean_object*); +static lean_object* l_Lake_Module_recBuildDeps___lambda__1___closed__1; +extern lean_object* l_Lake_instOrdJobAction; +static lean_object* l_Lake_Module_oNoExportFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___closed__1; +uint8_t l_instDecidableRelLt___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_compileLeanModule(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__4; +static lean_object* l_Lake_Module_bcFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__7; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___closed__1; +extern lean_object* l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_Module_recBuildLean___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__6(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Module_recBuildLean___spec__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__2___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_readTraceFile_x3f(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildLeanCToOExport___closed__5; +lean_object* l_Lake_Dynlib_dir_x3f(lean_object*); +LEAN_EXPORT lean_object* l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildTrace_mix(lean_object*, lean_object*); +uint8_t lean_string_validate_utf8(lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_recBuildExternDynlibs___spec__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__2(size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_ileanFacetConfig___closed__1; +static lean_object* l_Lake_Module_coExportFacetConfig___closed__5; +static lean_object* l_Lake_initModuleFacetConfigs___closed__5; +static lean_object* l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__1; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_Module_recBuildDeps___spec__6(lean_object*, lean_object*); +lean_object* l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_Module_recParseImports___spec__7(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_importsFacetConfig___closed__4; +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_List_elem___at_Lake_Module_recBuildDeps___spec__5(lean_object*, lean_object*); +lean_object* l_Lean_Name_mkStr3(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_Module_recParseImports___spec__5(lean_object*, lean_object*); +static lean_object* l_Lake_Module_dynlibFacetConfig___closed__4; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_clearOutputHashes(lean_object*, lean_object*); +extern uint64_t l_Lake_platformTrace; +size_t lean_usize_of_nat(lean_object*); +uint8_t l_String_isEmpty(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_instHashableModule___boxed(lean_object*); +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recParseImports___spec__8___at_Lake_Module_recParseImports___spec__9(lean_object*, lean_object*); +lean_object* lean_task_pure(lean_object*); +lean_object* l_Lake_Module_getMTime(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_collectImportsAux___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___boxed(lean_object**); +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__1; +lean_object* l_Lake_Module_checkExists(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_oleanFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Lake_Module_cacheOutputHashes(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_dynlibFacetConfig; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_Module_recBuildDeps___spec__4___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildLeanBcToO___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__12; +lean_object* l_Lake_Workspace_findModule_x3f___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__4(lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_elem___at_Lake_Module_recParseImports___spec__4___boxed(lean_object*, lean_object*); +lean_object* lean_nat_to_int(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_ByteArray_empty; +LEAN_EXPORT lean_object* l_Lake_Module_coExportFacetConfig; +LEAN_EXPORT lean_object* l_Lake_Module_depsFacetConfig; +static lean_object* l_Lake_Module_coNoExportFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lake_initModuleFacetConfigs; +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_collectImportsAux___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_coExportFacetConfig___closed__2; +static lean_object* l_Lake_Module_bcoFacetConfig___closed__3; +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_Module_recParseImports___spec__3(lean_object*, lean_object*); +lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildJob_collectArray___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_leanArtsFacetConfig; +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_withRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__1; +static lean_object* l_Lake_Module_oExportFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_bcFacetConfig; +static lean_object* l_Lake_initModuleFacetConfigs___closed__16; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputePrecompileImports___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_EXPORT lean_object* l_Lake_Module_precompileImportsFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_elem___at_Lake_Module_recBuildDeps___spec__5___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_Module_recBuildDeps___spec__8(lean_object*, lean_object*, lean_object*); +lean_object* lean_st_ref_get(lean_object*, lean_object*); +static lean_object* l_Lake_Module_ileanFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recBuildDeps___spec__9(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_st_mk_ref(lean_object*, lean_object*); +lean_object* lean_array_to_list(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +lean_object* l_Lake_JobState_merge(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_importsFacetConfig; +static lean_object* l_Lake_Module_bcFacetConfig___closed__1; +lean_object* lean_io_map_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +lean_object* l_Lake_Workspace_leanPath(lean_object*); +lean_object* l_panic___at_String_fromUTF8_x21___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__1(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildDeps___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_precompileImportsFacetConfig; +LEAN_EXPORT lean_object* l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static uint8_t l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___closed__1; +static lean_object* l_Lake_Module_recBuildDeps___lambda__1___closed__3; +static lean_object* l_Lake_Module_recBuildLeanBcToO___closed__1; +lean_object* l_Lake_cacheFileHash(lean_object*, lean_object*); +static lean_object* l_Lake_Module_importsFacetConfig___closed__1; +static lean_object* l_Lake_Module_oFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recBuildDeps___spec__9___at_Lake_Module_recBuildDeps___spec__10(lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +extern lean_object* l_Task_Priority_default; +static lean_object* l_Lake_Module_oNoExportFacetConfig___closed__3; +static lean_object* l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_cFacetConfig___closed__2; +uint8_t lean_name_eq(lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildLeanCToOExport___closed__1; +static lean_object* l_Lake_Module_oleanFacetConfig___closed__2; +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_coNoExportFacetConfig; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_IO_FS_Stream_ofBuffer(lean_object*); +static lean_object* l_Lake_Module_coExportFacetConfig___closed__4; +static lean_object* l_Lake_initModuleFacetConfigs___closed__17; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToONoExport(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(lean_object*, lean_object*); +lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_leanArtsFacetConfig___closed__5; +static lean_object* l_Lake_Module_cFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_get_set_stderr(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_EResult_map___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_coFacetConfig; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__3; +static lean_object* l_Lake_Module_recBuildLeanCToOExport___closed__2; +static lean_object* l_Lake_Module_oNoExportFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_ileanFacetConfig___elambda__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_oFacetConfig___closed__2; +lean_object* lean_string_from_utf8(lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputePrecompileImports___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_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(size_t, size_t, lean_object*); +static lean_object* l_Lake_Module_importsFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_bcoFacetConfig; +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(lean_object*, lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recComputeTransImports(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__3; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__1___closed__3___boxed__const__1; +static lean_object* l_Lake_Module_coExportFacetConfig___closed__1; +static lean_object* l_Lake_Module_leanArtsFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToONoExport___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_recParseImports___closed__1; +static lean_object* l_Lake_Module_depsFacetConfig___closed__4; +LEAN_EXPORT lean_object* l_Lake_recBuildExternDynlibs___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recBuildDeps___spec__11(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_IO_FS_readFile(lean_object*, lean_object*); +lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recBuildExternDynlibs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanBcToO___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__6; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_Module_recBuildDeps___spec__7(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_depsFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_Module_recBuildDeps___spec__4(lean_object*, lean_object*); +uint8_t l_Lake_instDecidableEqVerbosity(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11(lean_object*, lean_object*); +static lean_object* l_Lake_Module_cFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_leanArtsFacetConfig___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_coNoExportFacetConfig___closed__4; +lean_object* l_Lake_EquipT_lift___rarg___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_Module_recBuildLean___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_clearOutputHashes___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__2(lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__14; +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recParseImports___spec__10(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Module_recBuildLean___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildLean___lambda__3___closed__1; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_ileanFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_oNoExportFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildDynlib___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__3___boxed(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_OrdHashSet_empty___at_Lake_OrdModuleSet_empty___spec__1; +static lean_object* l_Lake_Module_oleanFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_bcFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildLeanCToONoExport___closed__1; +uint8_t l_Lake_Backend_orPreferLeft(uint8_t, uint8_t); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +static lean_object* l_Lake_recBuildExternDynlibs___closed__1; +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recBuildDeps___spec__11___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__11; +static lean_object* l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2; +static lean_object* l_Lake_Module_bcoFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_oExportFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +static lean_object* l_Lake_Module_depsFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_recBuildExternDynlibs___spec__1(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildJob_mixArray___rarg(lean_object*); +lean_object* l_Array_shrink___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_parseImports_x27(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__2; +static lean_object* l_Lake_Module_oleanFacetConfig___closed__4; +uint64_t l_Lean_Name_hash___override(lean_object*); +lean_object* lean_io_exit(uint8_t, lean_object*); +uint8_t l_instDecidableRelLe___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computePrecompileImportsAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_importsFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanBcToO___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_coFacetConfig___closed__2; +extern lean_object* l_Lake_Module_dynlibSuffix; +lean_object* l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_instHashablePackage___boxed(lean_object*); +lean_object* lean_task_map(lean_object*, lean_object*, lean_object*, uint8_t); +static lean_object* l_Lake_Module_recBuildDynlib___lambda__2___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__1; +lean_object* lean_nat_mul(lean_object*, lean_object*); +static lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1; +lean_object* lean_io_bind_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +static lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +lean_object* lean_get_set_stdin(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_oleanFacetConfig___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_transImportsFacetConfig___closed__2; +static lean_object* l_Lake_Module_precompileImportsFacetConfig___closed__1; +static lean_object* l_Lake_Module_coFacetConfig___closed__1; +static lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_clearOutputHashes___closed__4; +static lean_object* l_Lake_initModuleFacetConfigs___closed__3; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_recBuildDeps___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_ileanFacetConfig; +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__2; +uint8_t lean_internal_has_llvm_backend(lean_object*); +static lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__2; +size_t lean_usize_add(size_t, size_t); +static lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__1; +static lean_object* l_Lake_Module_leanArtsFacetConfig___closed__4; +lean_object* lean_array_uget(lean_object*, size_t); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_error_to_string(lean_object*); +static lean_object* l_Lake_Module_recBuildDeps___lambda__1___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_oExportFacetConfig; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_coNoExportFacetConfig___closed__3; +lean_object* l_Lean_modToFilePath(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__3(lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_instBEqPackage___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_coFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_Module_recParseImports___spec__3___boxed(lean_object*, lean_object*); +lean_object* l_Lake_writeTraceFile(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_precompileImportsFacetConfig___closed__2; +lean_object* lean_string_append(lean_object*, lean_object*); +extern uint32_t l_Lake_noBuildCode; +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Module_recBuildLean___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_oExportFacetConfig___closed__3; +lean_object* lean_array_get_size(lean_object*); +lean_object* l_Lake_fetchFileTrace___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_oNoExportFacetConfig; +static lean_object* l_Lake_Module_depsFacetConfig___closed__6; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___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_EXPORT lean_object* l_Lake_Module_recComputePrecompileImports(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_dynlibFacetConfig___closed__1; +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_importsFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_usize_dec_lt(size_t, size_t); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_depsFacetConfig___closed__2; +static lean_object* l_Lake_initModuleFacetConfigs___closed__9; +lean_object* l_Lean_Name_toStringWithSep(lean_object*, uint8_t, lean_object*); +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_dynlibFacetConfig___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__3(lean_object*, lean_object*); +lean_object* lean_nat_add(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recParseImports___spec__10___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +lean_object* l_Lake_BuildType_leancArgs(uint8_t); +static lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__2; +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___closed__1; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__1___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_leanArtsFacetConfig___closed__6; +extern uint8_t l_System_Platform_isWindows; +static lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__5___closed__1; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Module_dynlibFacetConfig___closed__3; +static lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2; +static lean_object* l_Lake_Module_recBuildLeanCToOExport___closed__3; +lean_object* l_Array_mapMUnsafe_map___at_Lake_Package_moreLeanArgs___spec__1(size_t, size_t, lean_object*); +lean_object* lean_array_uset(lean_object*, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___lambda__1(lean_object*); +lean_object* l_Lake_buildFileUnlessUpToDate(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_initModuleFacetConfigs___closed__15; +static lean_object* l_Lake_Module_leanArtsFacetConfig___closed__2; +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__1; +lean_object* l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_clearFileHash(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_collectImportsAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_collectImportsAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computePrecompileImportsAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Module_oFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__13(lean_object*, size_t, size_t, lean_object*); +static lean_object* l_Lake_Module_coExportFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_Lake_Module_oFacetConfig; +static lean_object* l_Lake_Module_bcoFacetConfig___closed__1; +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_recBuildExternDynlibs___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_4 = lean_ctor_get(x_3, 0); +x_5 = lean_ctor_get(x_3, 1); +x_6 = lean_ctor_get(x_3, 2); +x_7 = lean_ctor_get(x_3, 3); +lean_inc(x_1); +x_8 = l_Lean_RBNode_fold___at_Lake_recBuildExternDynlibs___spec__1(x_1, x_2, x_4); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_5); +lean_ctor_set(x_9, 2, x_6); +x_10 = lean_array_push(x_8, x_9); +x_2 = x_10; +x_3 = x_7; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2(size_t x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = lean_usize_dec_lt(x_2, x_1); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_3); +lean_ctor_set(x_11, 1, x_7); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_14 = lean_array_uget(x_3, x_2); +x_15 = lean_unsigned_to_nat(0u); +x_16 = lean_array_uset(x_3, x_2, x_15); +x_17 = lean_alloc_ctor(6, 1, 0); +lean_ctor_set(x_17, 0, x_14); +lean_inc(x_4); +lean_inc(x_6); +lean_inc(x_5); +x_18 = lean_apply_6(x_4, x_17, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +if (lean_obj_tag(x_20) == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; size_t x_25; size_t x_26; lean_object* x_27; +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_20, 1); +lean_inc(x_24); +lean_dec(x_20); +x_25 = 1; +x_26 = lean_usize_add(x_2, x_25); +x_27 = lean_array_uset(x_16, x_2, x_23); +x_2 = x_26; +x_3 = x_27; +x_7 = x_24; +x_8 = x_22; +x_9 = x_21; +goto _start; +} +else +{ +uint8_t x_29; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_29 = !lean_is_exclusive(x_18); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_18, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_19); +if (x_31 == 0) +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_19, 0); +lean_dec(x_32); +x_33 = !lean_is_exclusive(x_20); +if (x_33 == 0) +{ +return x_18; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_20, 0); +x_35 = lean_ctor_get(x_20, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_20); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +lean_ctor_set(x_19, 0, x_36); +return x_18; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_37 = lean_ctor_get(x_19, 1); +lean_inc(x_37); +lean_dec(x_19); +x_38 = lean_ctor_get(x_20, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_20, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_40 = x_20; +} else { + lean_dec_ref(x_20); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +lean_ctor_set(x_18, 0, x_42); +return x_18; +} +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_43 = lean_ctor_get(x_18, 1); +lean_inc(x_43); +lean_dec(x_18); +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_45 = x_19; +} else { + lean_dec_ref(x_19); + x_45 = lean_box(0); +} +x_46 = lean_ctor_get(x_20, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_20, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_48 = x_20; +} else { + lean_dec_ref(x_20); + x_48 = lean_box(0); +} +if (lean_is_scalar(x_48)) { + x_49 = lean_alloc_ctor(1, 2, 0); +} else { + x_49 = x_48; +} +lean_ctor_set(x_49, 0, x_46); +lean_ctor_set(x_49, 1, x_47); +if (lean_is_scalar(x_45)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_45; +} +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_44); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_43); +return x_51; +} +} +} +else +{ +uint8_t x_52; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_52 = !lean_is_exclusive(x_18); +if (x_52 == 0) +{ +return x_18; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_18, 0); +x_54 = lean_ctor_get(x_18, 1); +lean_inc(x_54); +lean_inc(x_53); +lean_dec(x_18); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +return x_55; +} +} +} +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; uint8_t x_54; +x_54 = lean_usize_dec_lt(x_3, x_2); +if (x_54 == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_4); +lean_ctor_set(x_55, 1, x_8); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; size_t x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; size_t x_73; lean_object* x_74; +x_58 = lean_array_uget(x_1, x_3); +x_59 = lean_ctor_get(x_4, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_4, 1); +lean_inc(x_60); +lean_dec(x_4); +x_61 = lean_ctor_get(x_58, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_58, 2); +lean_inc(x_62); +x_63 = lean_ctor_get(x_62, 8); +lean_inc(x_63); +x_64 = l_System_FilePath_join(x_61, x_63); +x_65 = lean_ctor_get(x_62, 10); +lean_inc(x_65); +lean_dec(x_62); +x_66 = l_System_FilePath_join(x_64, x_65); +x_67 = lean_array_push(x_60, x_66); +x_68 = lean_ctor_get(x_58, 10); +lean_inc(x_68); +x_69 = 0; +x_70 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +x_71 = l_Lean_RBNode_fold___at_Lake_recBuildExternDynlibs___spec__1(x_58, x_70, x_68); +lean_dec(x_68); +x_72 = lean_array_get_size(x_71); +x_73 = lean_usize_of_nat(x_72); +lean_dec(x_72); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +x_74 = l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2(x_73, x_69, x_71, x_5, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; lean_object* x_76; +x_75 = lean_ctor_get(x_74, 0); +lean_inc(x_75); +x_76 = lean_ctor_get(x_75, 0); +lean_inc(x_76); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; uint8_t x_78; +x_77 = lean_ctor_get(x_74, 1); +lean_inc(x_77); +lean_dec(x_74); +x_78 = !lean_is_exclusive(x_75); +if (x_78 == 0) +{ +lean_object* x_79; uint8_t x_80; +x_79 = lean_ctor_get(x_75, 0); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_76); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_81 = lean_ctor_get(x_76, 0); +x_82 = l_Array_append___rarg(x_59, x_81); +lean_dec(x_81); +x_83 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_67); +x_84 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_76, 0, x_84); +x_11 = x_75; +x_12 = x_77; +goto block_53; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_85 = lean_ctor_get(x_76, 0); +x_86 = lean_ctor_get(x_76, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_76); +x_87 = l_Array_append___rarg(x_59, x_85); +lean_dec(x_85); +x_88 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_67); +x_89 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_89, 0, x_88); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_86); +lean_ctor_set(x_75, 0, x_90); +x_11 = x_75; +x_12 = x_77; +goto block_53; +} +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_91 = lean_ctor_get(x_75, 1); +lean_inc(x_91); +lean_dec(x_75); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +x_95 = l_Array_append___rarg(x_59, x_92); +lean_dec(x_92); +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_67); +x_97 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_97, 0, x_96); +if (lean_is_scalar(x_94)) { + x_98 = lean_alloc_ctor(0, 2, 0); +} else { + x_98 = x_94; +} +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_93); +x_99 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_99, 0, x_98); +lean_ctor_set(x_99, 1, x_91); +x_11 = x_99; +x_12 = x_77; +goto block_53; +} +} +else +{ +lean_object* x_100; uint8_t x_101; +lean_dec(x_67); +lean_dec(x_59); +x_100 = lean_ctor_get(x_74, 1); +lean_inc(x_100); +lean_dec(x_74); +x_101 = !lean_is_exclusive(x_75); +if (x_101 == 0) +{ +lean_object* x_102; uint8_t x_103; +x_102 = lean_ctor_get(x_75, 0); +lean_dec(x_102); +x_103 = !lean_is_exclusive(x_76); +if (x_103 == 0) +{ +x_11 = x_75; +x_12 = x_100; +goto block_53; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_76, 0); +x_105 = lean_ctor_get(x_76, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_76); +x_106 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_106, 0, x_104); +lean_ctor_set(x_106, 1, x_105); +lean_ctor_set(x_75, 0, x_106); +x_11 = x_75; +x_12 = x_100; +goto block_53; +} +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_107 = lean_ctor_get(x_75, 1); +lean_inc(x_107); +lean_dec(x_75); +x_108 = lean_ctor_get(x_76, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_76, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_110 = x_76; +} else { + lean_dec_ref(x_76); + x_110 = lean_box(0); +} +if (lean_is_scalar(x_110)) { + x_111 = lean_alloc_ctor(1, 2, 0); +} else { + x_111 = x_110; +} +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_109); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_107); +x_11 = x_112; +x_12 = x_100; +goto block_53; +} +} +} +else +{ +uint8_t x_113; +lean_dec(x_67); +lean_dec(x_59); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_113 = !lean_is_exclusive(x_74); +if (x_113 == 0) +{ +return x_74; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_74, 0); +x_115 = lean_ctor_get(x_74, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_74); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +block_53: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; uint8_t x_17; +x_16 = lean_ctor_get(x_11, 0); +lean_dec(x_16); +x_17 = !lean_is_exclusive(x_13); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_13, 0); +lean_dec(x_18); +x_19 = lean_ctor_get(x_14, 0); +lean_inc(x_19); +lean_dec(x_14); +lean_ctor_set(x_13, 0, x_19); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_11); +lean_ctor_set(x_20, 1, x_12); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_13, 1); +lean_inc(x_21); +lean_dec(x_13); +x_22 = lean_ctor_get(x_14, 0); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_21); +lean_ctor_set(x_11, 0, x_23); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_11); +lean_ctor_set(x_24, 1, x_12); +return x_24; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_11, 1); +lean_inc(x_25); +lean_dec(x_11); +x_26 = lean_ctor_get(x_13, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_27 = x_13; +} else { + lean_dec_ref(x_13); + x_27 = lean_box(0); +} +x_28 = lean_ctor_get(x_14, 0); +lean_inc(x_28); +lean_dec(x_14); +if (lean_is_scalar(x_27)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_27; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_12); +return x_31; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; size_t x_35; size_t x_36; +x_32 = lean_ctor_get(x_11, 1); +lean_inc(x_32); +lean_dec(x_11); +x_33 = lean_ctor_get(x_13, 1); +lean_inc(x_33); +lean_dec(x_13); +x_34 = lean_ctor_get(x_14, 0); +lean_inc(x_34); +lean_dec(x_14); +x_35 = 1; +x_36 = lean_usize_add(x_3, x_35); +x_3 = x_36; +x_4 = x_34; +x_8 = x_33; +x_9 = x_32; +x_10 = x_12; +goto _start; +} +} +else +{ +uint8_t x_38; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_38 = !lean_is_exclusive(x_11); +if (x_38 == 0) +{ +lean_object* x_39; uint8_t x_40; +x_39 = lean_ctor_get(x_11, 0); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_13); +if (x_40 == 0) +{ +lean_object* x_41; +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_11); +lean_ctor_set(x_41, 1, x_12); +return x_41; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_42 = lean_ctor_get(x_13, 0); +x_43 = lean_ctor_get(x_13, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_13); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +lean_ctor_set(x_11, 0, x_44); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_11); +lean_ctor_set(x_45, 1, x_12); +return x_45; +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_46 = lean_ctor_get(x_11, 1); +lean_inc(x_46); +lean_dec(x_11); +x_47 = lean_ctor_get(x_13, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_13, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_49 = x_13; +} else { + lean_dec_ref(x_13); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_46); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_12); +return x_52; +} +} +} +} +} +static lean_object* _init_l_Lake_recBuildExternDynlibs___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +x_2 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_2, 0, x_1); +lean_ctor_set(x_2, 1, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_recBuildExternDynlibs(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; size_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_8 = lean_array_get_size(x_1); +x_9 = lean_usize_of_nat(x_8); +lean_dec(x_8); +x_10 = 0; +x_11 = l_Lake_recBuildExternDynlibs___closed__1; +x_12 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3(x_1, x_9, x_10, x_11, x_2, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_13); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_19 = lean_ctor_get(x_13, 1); +x_20 = lean_ctor_get(x_13, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_14); +if (x_21 == 0) +{ +lean_object* x_22; uint8_t x_23; +x_22 = lean_ctor_get(x_14, 0); +lean_dec(x_22); +x_23 = !lean_is_exclusive(x_15); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; +x_24 = lean_ctor_get(x_15, 0); +x_25 = lean_ctor_get(x_15, 1); +lean_ctor_set(x_13, 1, x_25); +lean_ctor_set(x_13, 0, x_24); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_15, 1, x_19); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_12, 0, x_15); +return x_12; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_15, 0); +x_27 = lean_ctor_get(x_15, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_15); +lean_ctor_set(x_13, 1, x_27); +lean_ctor_set(x_13, 0, x_26); +lean_ctor_set(x_14, 0, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_14); +lean_ctor_set(x_28, 1, x_19); +lean_ctor_set(x_12, 0, x_28); +return x_12; +} +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_29 = lean_ctor_get(x_14, 1); +lean_inc(x_29); +lean_dec(x_14); +x_30 = lean_ctor_get(x_15, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_15, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_32 = x_15; +} else { + lean_dec_ref(x_15); + x_32 = lean_box(0); +} +lean_ctor_set(x_13, 1, x_31); +lean_ctor_set(x_13, 0, x_30); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_13); +lean_ctor_set(x_33, 1, x_29); +if (lean_is_scalar(x_32)) { + x_34 = lean_alloc_ctor(0, 2, 0); +} else { + x_34 = x_32; +} +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_19); +lean_ctor_set(x_12, 0, x_34); +return x_12; +} +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_35 = lean_ctor_get(x_13, 1); +lean_inc(x_35); +lean_dec(x_13); +x_36 = lean_ctor_get(x_14, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_37 = x_14; +} else { + lean_dec_ref(x_14); + x_37 = lean_box(0); +} +x_38 = lean_ctor_get(x_15, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_15, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_40 = x_15; +} else { + lean_dec_ref(x_15); + x_40 = lean_box(0); +} +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +if (lean_is_scalar(x_37)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_37; +} +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_36); +if (lean_is_scalar(x_40)) { + x_43 = lean_alloc_ctor(0, 2, 0); +} else { + x_43 = x_40; +} +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_35); +lean_ctor_set(x_12, 0, x_43); +return x_12; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_44 = lean_ctor_get(x_12, 1); +lean_inc(x_44); +lean_dec(x_12); +x_45 = lean_ctor_get(x_13, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_46 = x_13; +} else { + lean_dec_ref(x_13); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_14, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_48 = x_14; +} else { + lean_dec_ref(x_14); + x_48 = lean_box(0); +} +x_49 = lean_ctor_get(x_15, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_15, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_51 = x_15; +} else { + lean_dec_ref(x_15); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_46)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_46; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +if (lean_is_scalar(x_48)) { + x_53 = lean_alloc_ctor(0, 2, 0); +} else { + x_53 = x_48; +} +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_47); +if (lean_is_scalar(x_51)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_51; +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_45); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_44); +return x_55; +} +} +else +{ +uint8_t x_56; +x_56 = !lean_is_exclusive(x_12); +if (x_56 == 0) +{ +lean_object* x_57; uint8_t x_58; +x_57 = lean_ctor_get(x_12, 0); +lean_dec(x_57); +x_58 = !lean_is_exclusive(x_13); +if (x_58 == 0) +{ +lean_object* x_59; uint8_t x_60; +x_59 = lean_ctor_get(x_13, 0); +lean_dec(x_59); +x_60 = !lean_is_exclusive(x_14); +if (x_60 == 0) +{ +return x_12; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_61 = lean_ctor_get(x_14, 0); +x_62 = lean_ctor_get(x_14, 1); +lean_inc(x_62); +lean_inc(x_61); +lean_dec(x_14); +x_63 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set(x_63, 1, x_62); +lean_ctor_set(x_13, 0, x_63); +return x_12; +} +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_64 = lean_ctor_get(x_13, 1); +lean_inc(x_64); +lean_dec(x_13); +x_65 = lean_ctor_get(x_14, 0); +lean_inc(x_65); +x_66 = lean_ctor_get(x_14, 1); +lean_inc(x_66); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_67 = x_14; +} else { + lean_dec_ref(x_14); + x_67 = lean_box(0); +} +if (lean_is_scalar(x_67)) { + x_68 = lean_alloc_ctor(1, 2, 0); +} else { + x_68 = x_67; +} +lean_ctor_set(x_68, 0, x_65); +lean_ctor_set(x_68, 1, x_66); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_64); +lean_ctor_set(x_12, 0, x_69); +return x_12; +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_70 = lean_ctor_get(x_12, 1); +lean_inc(x_70); +lean_dec(x_12); +x_71 = lean_ctor_get(x_13, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_72 = x_13; +} else { + lean_dec_ref(x_13); + x_72 = lean_box(0); +} +x_73 = lean_ctor_get(x_14, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_14, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_75 = x_14; +} else { + lean_dec_ref(x_14); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +if (lean_is_scalar(x_72)) { + x_77 = lean_alloc_ctor(0, 2, 0); +} else { + x_77 = x_72; +} +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_71); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_70); +return x_78; +} +} +} +else +{ +uint8_t x_79; +x_79 = !lean_is_exclusive(x_12); +if (x_79 == 0) +{ +return x_12; +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_80 = lean_ctor_get(x_12, 0); +x_81 = lean_ctor_get(x_12, 1); +lean_inc(x_81); +lean_inc(x_80); +lean_dec(x_12); +x_82 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_82, 0, x_80); +lean_ctor_set(x_82, 1, x_81); +return x_82; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_fold___at_Lake_recBuildExternDynlibs___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_fold___at_Lake_recBuildExternDynlibs___spec__1(x_1, x_2, x_3); +lean_dec(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; size_t x_11; lean_object* x_12; +x_10 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = l_Array_mapMUnsafe_map___at_Lake_recBuildExternDynlibs___spec__2(x_10, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_recBuildExternDynlibs___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_recBuildExternDynlibs(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_1); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_9); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_10); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_10, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_11); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_11, 0); +x_18 = lean_apply_1(x_1, x_17); +lean_ctor_set(x_11, 0, x_18); +return x_9; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_11, 0); +x_20 = lean_ctor_get(x_11, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_11); +x_21 = lean_apply_1(x_1, x_19); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +lean_ctor_set(x_10, 0, x_22); +return x_9; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_23 = lean_ctor_get(x_10, 1); +lean_inc(x_23); +lean_dec(x_10); +x_24 = lean_ctor_get(x_11, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_11, 1); +lean_inc(x_25); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_26 = x_11; +} else { + lean_dec_ref(x_11); + x_26 = lean_box(0); +} +x_27 = lean_apply_1(x_1, x_24); +if (lean_is_scalar(x_26)) { + x_28 = lean_alloc_ctor(0, 2, 0); +} else { + x_28 = x_26; +} +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_25); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_23); +lean_ctor_set(x_9, 0, x_29); +return x_9; +} +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_30 = lean_ctor_get(x_9, 1); +lean_inc(x_30); +lean_dec(x_9); +x_31 = lean_ctor_get(x_10, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_32 = x_10; +} else { + lean_dec_ref(x_10); + x_32 = lean_box(0); +} +x_33 = lean_ctor_get(x_11, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_35 = x_11; +} else { + lean_dec_ref(x_11); + x_35 = lean_box(0); +} +x_36 = lean_apply_1(x_1, x_33); +if (lean_is_scalar(x_35)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_35; +} +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_34); +if (lean_is_scalar(x_32)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_32; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_31); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_30); +return x_39; +} +} +else +{ +uint8_t x_40; +lean_dec(x_1); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +lean_object* x_41; uint8_t x_42; +x_41 = lean_ctor_get(x_9, 0); +lean_dec(x_41); +x_42 = !lean_is_exclusive(x_10); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_10, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_11); +if (x_44 == 0) +{ +return x_9; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_11, 0); +x_46 = lean_ctor_get(x_11, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_11); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_10, 0, x_47); +return x_9; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_10, 1); +lean_inc(x_48); +lean_dec(x_10); +x_49 = lean_ctor_get(x_11, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_11, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_51 = x_11; +} else { + lean_dec_ref(x_11); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +lean_ctor_set(x_9, 0, x_53); +return x_9; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_54 = lean_ctor_get(x_9, 1); +lean_inc(x_54); +lean_dec(x_9); +x_55 = lean_ctor_get(x_10, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_56 = x_10; +} else { + lean_dec_ref(x_10); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_11, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_11, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_59 = x_11; +} else { + lean_dec_ref(x_11); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +if (lean_is_scalar(x_56)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_56; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_55); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_54); +return x_62; +} +} +} +else +{ +uint8_t x_63; +lean_dec(x_1); +x_63 = !lean_is_exclusive(x_9); +if (x_63 == 0) +{ +return x_9; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_9, 0); +x_65 = lean_ctor_get(x_9, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_9); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +return x_66; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg), 8, 0); +return x_3; +} +} +LEAN_EXPORT uint8_t l_List_elem___at_Lake_Module_recParseImports___spec__4(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_4, 2); +x_7 = lean_ctor_get(x_1, 2); +x_8 = lean_name_eq(x_6, x_7); +if (x_8 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_10; +x_10 = 1; +return x_10; +} +} +} +} +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_Module_recParseImports___spec__3(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint64_t x_6; size_t x_7; lean_object* x_8; uint8_t x_9; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = lean_ctor_get(x_2, 2); +x_6 = l_Lean_Name_hash___override(x_5); +x_7 = lean_hashset_mk_idx(x_4, x_6); +x_8 = lean_array_uget(x_3, x_7); +x_9 = l_List_elem___at_Lake_Module_recParseImports___spec__4(x_2, x_8); +lean_dec(x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recParseImports___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_3, 1); +x_7 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_5); +x_8 = lean_apply_1(x_1, x_5); +x_9 = lean_unbox_uint64(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_7, x_9); +x_11 = lean_array_uget(x_2, x_10); +lean_ctor_set(x_3, 1, x_11); +x_12 = lean_array_uset(x_2, x_10, x_3); +x_2 = x_12; +x_3 = x_6; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint64_t x_18; size_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_14 = lean_ctor_get(x_3, 0); +x_15 = lean_ctor_get(x_3, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_3); +x_16 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_14); +x_17 = lean_apply_1(x_1, x_14); +x_18 = lean_unbox_uint64(x_17); +lean_dec(x_17); +x_19 = lean_hashset_mk_idx(x_16, x_18); +x_20 = lean_array_uget(x_2, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_14); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_array_uset(x_2, x_19, x_21); +x_2 = x_22; +x_3 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recParseImports___spec__8___at_Lake_Module_recParseImports___spec__9(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint64_t x_8; size_t x_9; lean_object* x_10; lean_object* x_11; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_array_get_size(x_1); +x_7 = lean_ctor_get(x_4, 2); +lean_inc(x_7); +x_8 = l_Lean_Name_hash___override(x_7); +lean_dec(x_7); +x_9 = lean_hashset_mk_idx(x_6, x_8); +x_10 = lean_array_uget(x_1, x_9); +lean_ctor_set(x_2, 1, x_10); +x_11 = lean_array_uset(x_1, x_9, x_2); +x_1 = x_11; +x_2 = x_5; +goto _start; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint64_t x_17; size_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_13 = lean_ctor_get(x_2, 0); +x_14 = lean_ctor_get(x_2, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_2); +x_15 = lean_array_get_size(x_1); +x_16 = lean_ctor_get(x_13, 2); +lean_inc(x_16); +x_17 = l_Lean_Name_hash___override(x_16); +lean_dec(x_16); +x_18 = lean_hashset_mk_idx(x_15, x_17); +x_19 = lean_array_uget(x_1, x_18); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_13); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_array_uset(x_1, x_18, x_20); +x_1 = x_21; +x_2 = x_14; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_Module_recParseImports___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_array_get_size(x_2); +x_5 = lean_nat_dec_lt(x_1, x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_6 = lean_array_fget(x_2, x_1); +x_7 = lean_box(0); +x_8 = lean_array_fset(x_2, x_1, x_7); +x_9 = l_List_foldl___at_Lake_Module_recParseImports___spec__8___at_Lake_Module_recParseImports___spec__9(x_3, x_6); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_8; +x_3 = x_9; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_Module_recParseImports___spec__6(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_nat_mul(x_3, x_4); +lean_dec(x_3); +x_6 = lean_box(0); +x_7 = lean_mk_array(x_5, x_6); +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_HashSetImp_moveEntries___at_Lake_Module_recParseImports___spec__7(x_8, x_2, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recParseImports___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; +lean_dec(x_3); +x_4 = lean_box(0); +return x_4; +} +else +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_1); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_6 = lean_ctor_get(x_1, 0); +x_7 = lean_ctor_get(x_1, 1); +x_8 = lean_ctor_get(x_6, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_2, 2); +x_10 = lean_name_eq(x_8, x_9); +lean_dec(x_8); +if (x_10 == 0) +{ +lean_object* x_11; +x_11 = l_List_replace___at_Lake_Module_recParseImports___spec__10(x_7, x_2, x_3); +lean_ctor_set(x_1, 1, x_11); +return x_1; +} +else +{ +lean_dec(x_6); +lean_ctor_set(x_1, 0, x_3); +return x_1; +} +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_12 = lean_ctor_get(x_1, 0); +x_13 = lean_ctor_get(x_1, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_1); +x_14 = lean_ctor_get(x_12, 2); +lean_inc(x_14); +x_15 = lean_ctor_get(x_2, 2); +x_16 = lean_name_eq(x_14, x_15); +lean_dec(x_14); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = l_List_replace___at_Lake_Module_recParseImports___spec__10(x_13, x_2, x_3); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_12); +lean_ctor_set(x_18, 1, x_17); +return x_18; +} +else +{ +lean_object* x_19; +lean_dec(x_12); +x_19 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_19, 0, x_3); +lean_ctor_set(x_19, 1, x_13); +return x_19; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_Module_recParseImports___spec__5(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_1); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint64_t x_8; size_t x_9; lean_object* x_10; uint8_t x_11; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_array_get_size(x_5); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = l_Lean_Name_hash___override(x_7); +lean_dec(x_7); +lean_inc(x_6); +x_9 = lean_hashset_mk_idx(x_6, x_8); +x_10 = lean_array_uget(x_5, x_9); +x_11 = l_List_elem___at_Lake_Module_recParseImports___spec__4(x_2, x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_12 = lean_unsigned_to_nat(1u); +x_13 = lean_nat_add(x_4, x_12); +lean_dec(x_4); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_2); +lean_ctor_set(x_14, 1, x_10); +x_15 = lean_array_uset(x_5, x_9, x_14); +x_16 = lean_nat_dec_le(x_13, x_6); +lean_dec(x_6); +if (x_16 == 0) +{ +lean_object* x_17; +lean_free_object(x_1); +x_17 = l_Lean_HashSetImp_expand___at_Lake_Module_recParseImports___spec__6(x_13, x_15); +return x_17; +} +else +{ +lean_ctor_set(x_1, 1, x_15); +lean_ctor_set(x_1, 0, x_13); +return x_1; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +lean_dec(x_6); +x_18 = lean_box(0); +x_19 = lean_array_uset(x_5, x_9, x_18); +lean_inc(x_2); +x_20 = l_List_replace___at_Lake_Module_recParseImports___spec__10(x_10, x_2, x_2); +lean_dec(x_2); +x_21 = lean_array_uset(x_19, x_9, x_20); +lean_ctor_set(x_1, 1, x_21); +return x_1; +} +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint64_t x_26; size_t x_27; lean_object* x_28; uint8_t x_29; +x_22 = lean_ctor_get(x_1, 0); +x_23 = lean_ctor_get(x_1, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_1); +x_24 = lean_array_get_size(x_23); +x_25 = lean_ctor_get(x_2, 2); +lean_inc(x_25); +x_26 = l_Lean_Name_hash___override(x_25); +lean_dec(x_25); +lean_inc(x_24); +x_27 = lean_hashset_mk_idx(x_24, x_26); +x_28 = lean_array_uget(x_23, x_27); +x_29 = l_List_elem___at_Lake_Module_recParseImports___spec__4(x_2, x_28); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; +x_30 = lean_unsigned_to_nat(1u); +x_31 = lean_nat_add(x_22, x_30); +lean_dec(x_22); +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_2); +lean_ctor_set(x_32, 1, x_28); +x_33 = lean_array_uset(x_23, x_27, x_32); +x_34 = lean_nat_dec_le(x_31, x_24); +lean_dec(x_24); +if (x_34 == 0) +{ +lean_object* x_35; +x_35 = l_Lean_HashSetImp_expand___at_Lake_Module_recParseImports___spec__6(x_31, x_33); +return x_35; +} +else +{ +lean_object* x_36; +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_31); +lean_ctor_set(x_36, 1, x_33); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +lean_dec(x_24); +x_37 = lean_box(0); +x_38 = lean_array_uset(x_23, x_27, x_37); +lean_inc(x_2); +x_39 = l_List_replace___at_Lake_Module_recParseImports___spec__10(x_28, x_2, x_2); +lean_dec(x_2); +x_40 = lean_array_uset(x_38, x_27, x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_22); +lean_ctor_set(x_41, 1, x_40); +return x_41; +} +} +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instHashableModule___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instBEqModule___boxed), 2, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = l_Lean_HashSetImp_contains___at_Lake_Module_recParseImports___spec__3(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +lean_inc(x_2); +x_6 = lean_array_push(x_5, x_2); +x_7 = l_Lean_HashSetImp_insert___at_Lake_Module_recParseImports___spec__5(x_3, x_2); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +return x_8; +} +else +{ +lean_dec(x_3); +lean_dec(x_2); +return x_1; +} +} +} +LEAN_EXPORT lean_object* l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = lean_apply_6(x_1, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_9); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_10); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_10, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_11); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_11, 0); +x_18 = lean_apply_1(x_2, x_17); +lean_ctor_set(x_11, 0, x_18); +return x_9; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_11, 0); +x_20 = lean_ctor_get(x_11, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_11); +x_21 = lean_apply_1(x_2, x_19); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +lean_ctor_set(x_10, 0, x_22); +return x_9; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_23 = lean_ctor_get(x_10, 1); +lean_inc(x_23); +lean_dec(x_10); +x_24 = lean_ctor_get(x_11, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_11, 1); +lean_inc(x_25); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_26 = x_11; +} else { + lean_dec_ref(x_11); + x_26 = lean_box(0); +} +x_27 = lean_apply_1(x_2, x_24); +if (lean_is_scalar(x_26)) { + x_28 = lean_alloc_ctor(0, 2, 0); +} else { + x_28 = x_26; +} +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_25); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_23); +lean_ctor_set(x_9, 0, x_29); +return x_9; +} +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_30 = lean_ctor_get(x_9, 1); +lean_inc(x_30); +lean_dec(x_9); +x_31 = lean_ctor_get(x_10, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_32 = x_10; +} else { + lean_dec_ref(x_10); + x_32 = lean_box(0); +} +x_33 = lean_ctor_get(x_11, 0); +lean_inc(x_33); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_35 = x_11; +} else { + lean_dec_ref(x_11); + x_35 = lean_box(0); +} +x_36 = lean_apply_1(x_2, x_33); +if (lean_is_scalar(x_35)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_35; +} +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_34); +if (lean_is_scalar(x_32)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_32; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_31); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_30); +return x_39; +} +} +else +{ +uint8_t x_40; +lean_dec(x_2); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +lean_object* x_41; uint8_t x_42; +x_41 = lean_ctor_get(x_9, 0); +lean_dec(x_41); +x_42 = !lean_is_exclusive(x_10); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_10, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_11); +if (x_44 == 0) +{ +return x_9; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_11, 0); +x_46 = lean_ctor_get(x_11, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_11); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_10, 0, x_47); +return x_9; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_10, 1); +lean_inc(x_48); +lean_dec(x_10); +x_49 = lean_ctor_get(x_11, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_11, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_51 = x_11; +} else { + lean_dec_ref(x_11); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +lean_ctor_set(x_9, 0, x_53); +return x_9; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_54 = lean_ctor_get(x_9, 1); +lean_inc(x_54); +lean_dec(x_9); +x_55 = lean_ctor_get(x_10, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_56 = x_10; +} else { + lean_dec_ref(x_10); + x_56 = lean_box(0); +} +x_57 = lean_ctor_get(x_11, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_11, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_59 = x_11; +} else { + lean_dec_ref(x_11); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +if (lean_is_scalar(x_56)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_56; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_55); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_54); +return x_62; +} +} +} +else +{ +uint8_t x_63; +lean_dec(x_2); +x_63 = !lean_is_exclusive(x_9); +if (x_63 == 0) +{ +return x_9; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_9, 0); +x_65 = lean_ctor_get(x_9, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_9); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +return x_66; +} +} +} +} +LEAN_EXPORT lean_object* l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11___rarg), 8, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__1(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_4); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_5); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__3(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_2, 0); +lean_inc(x_3); +lean_dec(x_2); +x_4 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_1, x_3); +return x_4; +} +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__2___boxed), 5, 0); +return x_1; +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EquipT_lift___rarg___boxed), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; +x_11 = lean_usize_dec_eq(x_2, x_3); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_12 = lean_array_uget(x_1, x_2); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +lean_dec(x_12); +x_14 = lean_alloc_closure((void*)(l_Lake_Workspace_findModule_x3f___boxed), 2, 1); +lean_closure_set(x_14, 0, x_13); +x_15 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__3; +x_16 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__2; +x_17 = lean_alloc_closure((void*)(l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg), 8, 2); +lean_closure_set(x_17, 0, x_15); +lean_closure_set(x_17, 1, x_16); +x_18 = lean_alloc_closure((void*)(l_Lake_EquipT_map___at_Lake_Module_recParseImports___spec__1___rarg), 8, 2); +lean_closure_set(x_18, 0, x_14); +lean_closure_set(x_18, 1, x_17); +x_19 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__3), 2, 1); +lean_closure_set(x_19, 0, x_4); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +x_20 = l_Functor_mapRev___at_Lake_Module_recParseImports___spec__11___rarg(x_18, x_19, x_5, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_20) == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +x_22 = lean_ctor_get(x_21, 0); +lean_inc(x_22); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; size_t x_27; size_t x_28; +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 1); +lean_inc(x_24); +lean_dec(x_21); +x_25 = lean_ctor_get(x_22, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_22, 1); +lean_inc(x_26); +lean_dec(x_22); +x_27 = 1; +x_28 = lean_usize_add(x_2, x_27); +x_2 = x_28; +x_4 = x_25; +x_8 = x_26; +x_9 = x_24; +x_10 = x_23; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_30 = !lean_is_exclusive(x_20); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_20, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_21); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_21, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_22); +if (x_34 == 0) +{ +return x_20; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_22, 0); +x_36 = lean_ctor_get(x_22, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_22); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_21, 0, x_37); +return x_20; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_21, 1); +lean_inc(x_38); +lean_dec(x_21); +x_39 = lean_ctor_get(x_22, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_22, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_41 = x_22; +} else { + lean_dec_ref(x_22); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +lean_ctor_set(x_20, 0, x_43); +return x_20; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_20, 1); +lean_inc(x_44); +lean_dec(x_20); +x_45 = lean_ctor_get(x_21, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_46 = x_21; +} else { + lean_dec_ref(x_21); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_22, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_22, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_49 = x_22; +} else { + lean_dec_ref(x_22); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +if (lean_is_scalar(x_46)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_46; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_45); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_53 = !lean_is_exclusive(x_20); +if (x_53 == 0) +{ +return x_20; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_20, 0); +x_55 = lean_ctor_get(x_20, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_20); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_4); +lean_ctor_set(x_57, 1, x_8); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_9); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_10); +return x_59; +} +} +} +static lean_object* _init_l_Lake_Module_recParseImports___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("lean", 4); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recParseImports(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_270; +x_192 = lean_ctor_get(x_1, 0); +lean_inc(x_192); +x_193 = lean_ctor_get(x_192, 0); +lean_inc(x_193); +x_194 = lean_ctor_get(x_193, 0); +lean_inc(x_194); +x_195 = lean_ctor_get(x_193, 2); +lean_inc(x_195); +lean_dec(x_193); +x_196 = lean_ctor_get(x_195, 7); +lean_inc(x_196); +lean_dec(x_195); +x_197 = l_System_FilePath_join(x_194, x_196); +x_198 = lean_ctor_get(x_192, 1); +lean_inc(x_198); +lean_dec(x_192); +x_199 = lean_ctor_get(x_198, 2); +lean_inc(x_199); +lean_dec(x_198); +x_200 = l_System_FilePath_join(x_197, x_199); +x_201 = lean_ctor_get(x_1, 1); +lean_inc(x_201); +lean_dec(x_1); +x_202 = l_Lake_Module_recParseImports___closed__1; +x_203 = l_Lean_modToFilePath(x_200, x_201, x_202); +lean_dec(x_200); +x_270 = l_IO_FS_readFile(x_203, x_7); +if (lean_obj_tag(x_270) == 0) +{ +uint8_t x_271; +x_271 = !lean_is_exclusive(x_270); +if (x_271 == 0) +{ +lean_object* x_272; lean_object* x_273; +x_272 = lean_ctor_get(x_270, 1); +lean_ctor_set(x_270, 1, x_5); +x_273 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_273, 0, x_270); +lean_ctor_set(x_273, 1, x_6); +x_204 = x_273; +x_205 = x_272; +goto block_269; +} +else +{ +lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; +x_274 = lean_ctor_get(x_270, 0); +x_275 = lean_ctor_get(x_270, 1); +lean_inc(x_275); +lean_inc(x_274); +lean_dec(x_270); +x_276 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_276, 0, x_274); +lean_ctor_set(x_276, 1, x_5); +x_277 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_277, 0, x_276); +lean_ctor_set(x_277, 1, x_6); +x_204 = x_277; +x_205 = x_275; +goto block_269; +} +} +else +{ +uint8_t x_278; +x_278 = !lean_is_exclusive(x_270); +if (x_278 == 0) +{ +lean_object* x_279; lean_object* x_280; lean_object* x_281; uint8_t x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; +x_279 = lean_ctor_get(x_270, 0); +x_280 = lean_ctor_get(x_270, 1); +x_281 = lean_io_error_to_string(x_279); +x_282 = 3; +x_283 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_283, 0, x_281); +lean_ctor_set_uint8(x_283, sizeof(void*)*1, x_282); +x_284 = lean_array_get_size(x_5); +x_285 = lean_array_push(x_5, x_283); +lean_ctor_set(x_270, 1, x_285); +lean_ctor_set(x_270, 0, x_284); +x_286 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_286, 0, x_270); +lean_ctor_set(x_286, 1, x_6); +x_204 = x_286; +x_205 = x_280; +goto block_269; +} +else +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; uint8_t x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_287 = lean_ctor_get(x_270, 0); +x_288 = lean_ctor_get(x_270, 1); +lean_inc(x_288); +lean_inc(x_287); +lean_dec(x_270); +x_289 = lean_io_error_to_string(x_287); +x_290 = 3; +x_291 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_291, 0, x_289); +lean_ctor_set_uint8(x_291, sizeof(void*)*1, x_290); +x_292 = lean_array_get_size(x_5); +x_293 = lean_array_push(x_5, x_291); +x_294 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_294, 0, x_292); +lean_ctor_set(x_294, 1, x_293); +x_295 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_6); +x_204 = x_295; +x_205 = x_288; +goto block_269; +} +} +block_191: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_8); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_8, 1); +x_13 = lean_ctor_get(x_8, 0); +lean_dec(x_13); +x_14 = !lean_is_exclusive(x_10); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; +x_15 = lean_ctor_get(x_10, 0); +x_16 = lean_ctor_get(x_10, 1); +x_17 = lean_array_get_size(x_15); +x_18 = lean_unsigned_to_nat(0u); +x_19 = lean_nat_dec_lt(x_18, x_17); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; +lean_dec(x_17); +lean_dec(x_15); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_20 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +lean_ctor_set(x_10, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_8); +lean_ctor_set(x_21, 1, x_9); +return x_21; +} +else +{ +uint8_t x_22; +x_22 = lean_nat_dec_le(x_17, x_17); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; +lean_dec(x_17); +lean_dec(x_15); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_23 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +lean_ctor_set(x_10, 0, x_23); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_8); +lean_ctor_set(x_24, 1, x_9); +return x_24; +} +else +{ +size_t x_25; size_t x_26; lean_object* x_27; lean_object* x_28; +lean_free_object(x_10); +lean_free_object(x_8); +x_25 = 0; +x_26 = lean_usize_of_nat(x_17); +lean_dec(x_17); +x_27 = l_Lake_OrdHashSet_empty___at_Lake_OrdModuleSet_empty___spec__1; +x_28 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12(x_15, x_25, x_26, x_27, x_2, x_3, x_4, x_16, x_12, x_9); +lean_dec(x_15); +if (lean_obj_tag(x_28) == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +if (lean_obj_tag(x_30) == 0) +{ +uint8_t x_31; +x_31 = !lean_is_exclusive(x_28); +if (x_31 == 0) +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_28, 0); +lean_dec(x_32); +x_33 = !lean_is_exclusive(x_29); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = lean_ctor_get(x_29, 0); +lean_dec(x_34); +x_35 = !lean_is_exclusive(x_30); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; +x_36 = lean_ctor_get(x_30, 0); +x_37 = lean_ctor_get(x_36, 1); +lean_inc(x_37); +lean_dec(x_36); +lean_ctor_set(x_30, 0, x_37); +return x_28; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_30, 0); +x_39 = lean_ctor_get(x_30, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_30); +x_40 = lean_ctor_get(x_38, 1); +lean_inc(x_40); +lean_dec(x_38); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_39); +lean_ctor_set(x_29, 0, x_41); +return x_28; +} +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_42 = lean_ctor_get(x_29, 1); +lean_inc(x_42); +lean_dec(x_29); +x_43 = lean_ctor_get(x_30, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_30, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_30)) { + lean_ctor_release(x_30, 0); + lean_ctor_release(x_30, 1); + x_45 = x_30; +} else { + lean_dec_ref(x_30); + x_45 = lean_box(0); +} +x_46 = lean_ctor_get(x_43, 1); +lean_inc(x_46); +lean_dec(x_43); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_44); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_42); +lean_ctor_set(x_28, 0, x_48); +return x_28; +} +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_49 = lean_ctor_get(x_28, 1); +lean_inc(x_49); +lean_dec(x_28); +x_50 = lean_ctor_get(x_29, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_51 = x_29; +} else { + lean_dec_ref(x_29); + x_51 = lean_box(0); +} +x_52 = lean_ctor_get(x_30, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_30, 1); +lean_inc(x_53); +if (lean_is_exclusive(x_30)) { + lean_ctor_release(x_30, 0); + lean_ctor_release(x_30, 1); + x_54 = x_30; +} else { + lean_dec_ref(x_30); + x_54 = lean_box(0); +} +x_55 = lean_ctor_get(x_52, 1); +lean_inc(x_55); +lean_dec(x_52); +if (lean_is_scalar(x_54)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_54; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_53); +if (lean_is_scalar(x_51)) { + x_57 = lean_alloc_ctor(0, 2, 0); +} else { + x_57 = x_51; +} +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_50); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_49); +return x_58; +} +} +else +{ +uint8_t x_59; +x_59 = !lean_is_exclusive(x_28); +if (x_59 == 0) +{ +lean_object* x_60; uint8_t x_61; +x_60 = lean_ctor_get(x_28, 0); +lean_dec(x_60); +x_61 = !lean_is_exclusive(x_29); +if (x_61 == 0) +{ +lean_object* x_62; uint8_t x_63; +x_62 = lean_ctor_get(x_29, 0); +lean_dec(x_62); +x_63 = !lean_is_exclusive(x_30); +if (x_63 == 0) +{ +return x_28; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_30, 0); +x_65 = lean_ctor_get(x_30, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_30); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +lean_ctor_set(x_29, 0, x_66); +return x_28; +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_67 = lean_ctor_get(x_29, 1); +lean_inc(x_67); +lean_dec(x_29); +x_68 = lean_ctor_get(x_30, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_30, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_30)) { + lean_ctor_release(x_30, 0); + lean_ctor_release(x_30, 1); + x_70 = x_30; +} else { + lean_dec_ref(x_30); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_67); +lean_ctor_set(x_28, 0, x_72); +return x_28; +} +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_73 = lean_ctor_get(x_28, 1); +lean_inc(x_73); +lean_dec(x_28); +x_74 = lean_ctor_get(x_29, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_75 = x_29; +} else { + lean_dec_ref(x_29); + x_75 = lean_box(0); +} +x_76 = lean_ctor_get(x_30, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_30, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_30)) { + lean_ctor_release(x_30, 0); + lean_ctor_release(x_30, 1); + x_78 = x_30; +} else { + lean_dec_ref(x_30); + x_78 = lean_box(0); +} +if (lean_is_scalar(x_78)) { + x_79 = lean_alloc_ctor(1, 2, 0); +} else { + x_79 = x_78; +} +lean_ctor_set(x_79, 0, x_76); +lean_ctor_set(x_79, 1, x_77); +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 2, 0); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_74); +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_73); +return x_81; +} +} +} +else +{ +uint8_t x_82; +x_82 = !lean_is_exclusive(x_28); +if (x_82 == 0) +{ +return x_28; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_83 = lean_ctor_get(x_28, 0); +x_84 = lean_ctor_get(x_28, 1); +lean_inc(x_84); +lean_inc(x_83); +lean_dec(x_28); +x_85 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_85, 0, x_83); +lean_ctor_set(x_85, 1, x_84); +return x_85; +} +} +} +} +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; +x_86 = lean_ctor_get(x_10, 0); +x_87 = lean_ctor_get(x_10, 1); +lean_inc(x_87); +lean_inc(x_86); +lean_dec(x_10); +x_88 = lean_array_get_size(x_86); +x_89 = lean_unsigned_to_nat(0u); +x_90 = lean_nat_dec_lt(x_89, x_88); +if (x_90 == 0) +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; +lean_dec(x_88); +lean_dec(x_86); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_91 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_87); +lean_ctor_set(x_8, 0, x_92); +x_93 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_93, 0, x_8); +lean_ctor_set(x_93, 1, x_9); +return x_93; +} +else +{ +uint8_t x_94; +x_94 = lean_nat_dec_le(x_88, x_88); +if (x_94 == 0) +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; +lean_dec(x_88); +lean_dec(x_86); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_95 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_87); +lean_ctor_set(x_8, 0, x_96); +x_97 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_97, 0, x_8); +lean_ctor_set(x_97, 1, x_9); +return x_97; +} +else +{ +size_t x_98; size_t x_99; lean_object* x_100; lean_object* x_101; +lean_free_object(x_8); +x_98 = 0; +x_99 = lean_usize_of_nat(x_88); +lean_dec(x_88); +x_100 = l_Lake_OrdHashSet_empty___at_Lake_OrdModuleSet_empty___spec__1; +x_101 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12(x_86, x_98, x_99, x_100, x_2, x_3, x_4, x_87, x_12, x_9); +lean_dec(x_86); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; +x_102 = lean_ctor_get(x_101, 0); +lean_inc(x_102); +x_103 = lean_ctor_get(x_102, 0); +lean_inc(x_103); +if (lean_obj_tag(x_103) == 0) +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; +x_104 = lean_ctor_get(x_101, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_105 = x_101; +} else { + lean_dec_ref(x_101); + x_105 = lean_box(0); +} +x_106 = lean_ctor_get(x_102, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_102)) { + lean_ctor_release(x_102, 0); + lean_ctor_release(x_102, 1); + x_107 = x_102; +} else { + lean_dec_ref(x_102); + x_107 = lean_box(0); +} +x_108 = lean_ctor_get(x_103, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_103, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_103)) { + lean_ctor_release(x_103, 0); + lean_ctor_release(x_103, 1); + x_110 = x_103; +} else { + lean_dec_ref(x_103); + x_110 = lean_box(0); +} +x_111 = lean_ctor_get(x_108, 1); +lean_inc(x_111); +lean_dec(x_108); +if (lean_is_scalar(x_110)) { + x_112 = lean_alloc_ctor(0, 2, 0); +} else { + x_112 = x_110; +} +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_109); +if (lean_is_scalar(x_107)) { + x_113 = lean_alloc_ctor(0, 2, 0); +} else { + x_113 = x_107; +} +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_106); +if (lean_is_scalar(x_105)) { + x_114 = lean_alloc_ctor(0, 2, 0); +} else { + x_114 = x_105; +} +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_114, 1, x_104); +return x_114; +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +x_115 = lean_ctor_get(x_101, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_116 = x_101; +} else { + lean_dec_ref(x_101); + x_116 = lean_box(0); +} +x_117 = lean_ctor_get(x_102, 1); +lean_inc(x_117); +if (lean_is_exclusive(x_102)) { + lean_ctor_release(x_102, 0); + lean_ctor_release(x_102, 1); + x_118 = x_102; +} else { + lean_dec_ref(x_102); + x_118 = lean_box(0); +} +x_119 = lean_ctor_get(x_103, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_103, 1); +lean_inc(x_120); +if (lean_is_exclusive(x_103)) { + lean_ctor_release(x_103, 0); + lean_ctor_release(x_103, 1); + x_121 = x_103; +} else { + lean_dec_ref(x_103); + x_121 = lean_box(0); +} +if (lean_is_scalar(x_121)) { + x_122 = lean_alloc_ctor(1, 2, 0); +} else { + x_122 = x_121; +} +lean_ctor_set(x_122, 0, x_119); +lean_ctor_set(x_122, 1, x_120); +if (lean_is_scalar(x_118)) { + x_123 = lean_alloc_ctor(0, 2, 0); +} else { + x_123 = x_118; +} +lean_ctor_set(x_123, 0, x_122); +lean_ctor_set(x_123, 1, x_117); +if (lean_is_scalar(x_116)) { + x_124 = lean_alloc_ctor(0, 2, 0); +} else { + x_124 = x_116; +} +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_115); +return x_124; +} +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_125 = lean_ctor_get(x_101, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_101, 1); +lean_inc(x_126); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_127 = x_101; +} else { + lean_dec_ref(x_101); + x_127 = lean_box(0); +} +if (lean_is_scalar(x_127)) { + x_128 = lean_alloc_ctor(1, 2, 0); +} else { + x_128 = x_127; +} +lean_ctor_set(x_128, 0, x_125); +lean_ctor_set(x_128, 1, x_126); +return x_128; +} +} +} +} +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; uint8_t x_135; +x_129 = lean_ctor_get(x_8, 1); +lean_inc(x_129); +lean_dec(x_8); +x_130 = lean_ctor_get(x_10, 0); +lean_inc(x_130); +x_131 = lean_ctor_get(x_10, 1); +lean_inc(x_131); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_132 = x_10; +} else { + lean_dec_ref(x_10); + x_132 = lean_box(0); +} +x_133 = lean_array_get_size(x_130); +x_134 = lean_unsigned_to_nat(0u); +x_135 = lean_nat_dec_lt(x_134, x_133); +if (x_135 == 0) +{ +lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +lean_dec(x_133); +lean_dec(x_130); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_136 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +if (lean_is_scalar(x_132)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_132; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_131); +x_138 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_138, 0, x_137); +lean_ctor_set(x_138, 1, x_129); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_9); +return x_139; +} +else +{ +uint8_t x_140; +x_140 = lean_nat_dec_le(x_133, x_133); +if (x_140 == 0) +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; +lean_dec(x_133); +lean_dec(x_130); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_141 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +if (lean_is_scalar(x_132)) { + x_142 = lean_alloc_ctor(0, 2, 0); +} else { + x_142 = x_132; +} +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_131); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_142); +lean_ctor_set(x_143, 1, x_129); +x_144 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_144, 0, x_143); +lean_ctor_set(x_144, 1, x_9); +return x_144; +} +else +{ +size_t x_145; size_t x_146; lean_object* x_147; lean_object* x_148; +lean_dec(x_132); +x_145 = 0; +x_146 = lean_usize_of_nat(x_133); +lean_dec(x_133); +x_147 = l_Lake_OrdHashSet_empty___at_Lake_OrdModuleSet_empty___spec__1; +x_148 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12(x_130, x_145, x_146, x_147, x_2, x_3, x_4, x_131, x_129, x_9); +lean_dec(x_130); +if (lean_obj_tag(x_148) == 0) +{ +lean_object* x_149; lean_object* x_150; +x_149 = lean_ctor_get(x_148, 0); +lean_inc(x_149); +x_150 = lean_ctor_get(x_149, 0); +lean_inc(x_150); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; +x_151 = lean_ctor_get(x_148, 1); +lean_inc(x_151); +if (lean_is_exclusive(x_148)) { + lean_ctor_release(x_148, 0); + lean_ctor_release(x_148, 1); + x_152 = x_148; +} else { + lean_dec_ref(x_148); + x_152 = lean_box(0); +} +x_153 = lean_ctor_get(x_149, 1); +lean_inc(x_153); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_154 = x_149; +} else { + lean_dec_ref(x_149); + x_154 = lean_box(0); +} +x_155 = lean_ctor_get(x_150, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_150, 1); +lean_inc(x_156); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_157 = x_150; +} else { + lean_dec_ref(x_150); + x_157 = lean_box(0); +} +x_158 = lean_ctor_get(x_155, 1); +lean_inc(x_158); +lean_dec(x_155); +if (lean_is_scalar(x_157)) { + x_159 = lean_alloc_ctor(0, 2, 0); +} else { + x_159 = x_157; +} +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_156); +if (lean_is_scalar(x_154)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_154; +} +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_153); +if (lean_is_scalar(x_152)) { + x_161 = lean_alloc_ctor(0, 2, 0); +} else { + x_161 = x_152; +} +lean_ctor_set(x_161, 0, x_160); +lean_ctor_set(x_161, 1, x_151); +return x_161; +} +else +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; +x_162 = lean_ctor_get(x_148, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_148)) { + lean_ctor_release(x_148, 0); + lean_ctor_release(x_148, 1); + x_163 = x_148; +} else { + lean_dec_ref(x_148); + x_163 = lean_box(0); +} +x_164 = lean_ctor_get(x_149, 1); +lean_inc(x_164); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_165 = x_149; +} else { + lean_dec_ref(x_149); + x_165 = lean_box(0); +} +x_166 = lean_ctor_get(x_150, 0); +lean_inc(x_166); +x_167 = lean_ctor_get(x_150, 1); +lean_inc(x_167); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_168 = x_150; +} else { + lean_dec_ref(x_150); + x_168 = lean_box(0); +} +if (lean_is_scalar(x_168)) { + x_169 = lean_alloc_ctor(1, 2, 0); +} else { + x_169 = x_168; +} +lean_ctor_set(x_169, 0, x_166); +lean_ctor_set(x_169, 1, x_167); +if (lean_is_scalar(x_165)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_165; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_164); +if (lean_is_scalar(x_163)) { + x_171 = lean_alloc_ctor(0, 2, 0); +} else { + x_171 = x_163; +} +lean_ctor_set(x_171, 0, x_170); +lean_ctor_set(x_171, 1, x_162); +return x_171; +} +} +else +{ +lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; +x_172 = lean_ctor_get(x_148, 0); +lean_inc(x_172); +x_173 = lean_ctor_get(x_148, 1); +lean_inc(x_173); +if (lean_is_exclusive(x_148)) { + lean_ctor_release(x_148, 0); + lean_ctor_release(x_148, 1); + x_174 = x_148; +} else { + lean_dec_ref(x_148); + x_174 = lean_box(0); +} +if (lean_is_scalar(x_174)) { + x_175 = lean_alloc_ctor(1, 2, 0); +} else { + x_175 = x_174; +} +lean_ctor_set(x_175, 0, x_172); +lean_ctor_set(x_175, 1, x_173); +return x_175; +} +} +} +} +} +else +{ +uint8_t x_176; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_176 = !lean_is_exclusive(x_8); +if (x_176 == 0) +{ +lean_object* x_177; uint8_t x_178; +x_177 = lean_ctor_get(x_8, 0); +lean_dec(x_177); +x_178 = !lean_is_exclusive(x_10); +if (x_178 == 0) +{ +lean_object* x_179; +x_179 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_179, 0, x_8); +lean_ctor_set(x_179, 1, x_9); +return x_179; +} +else +{ +lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_180 = lean_ctor_get(x_10, 0); +x_181 = lean_ctor_get(x_10, 1); +lean_inc(x_181); +lean_inc(x_180); +lean_dec(x_10); +x_182 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_182, 0, x_180); +lean_ctor_set(x_182, 1, x_181); +lean_ctor_set(x_8, 0, x_182); +x_183 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_183, 0, x_8); +lean_ctor_set(x_183, 1, x_9); +return x_183; +} +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; +x_184 = lean_ctor_get(x_8, 1); +lean_inc(x_184); +lean_dec(x_8); +x_185 = lean_ctor_get(x_10, 0); +lean_inc(x_185); +x_186 = lean_ctor_get(x_10, 1); +lean_inc(x_186); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_187 = x_10; +} else { + lean_dec_ref(x_10); + x_187 = lean_box(0); +} +if (lean_is_scalar(x_187)) { + x_188 = lean_alloc_ctor(1, 2, 0); +} else { + x_188 = x_187; +} +lean_ctor_set(x_188, 0, x_185); +lean_ctor_set(x_188, 1, x_186); +x_189 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_189, 0, x_188); +lean_ctor_set(x_189, 1, x_184); +x_190 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_190, 0, x_189); +lean_ctor_set(x_190, 1, x_9); +return x_190; +} +} +} +block_269: +{ +lean_object* x_206; +x_206 = lean_ctor_get(x_204, 0); +lean_inc(x_206); +if (lean_obj_tag(x_206) == 0) +{ +uint8_t x_207; +x_207 = !lean_is_exclusive(x_204); +if (x_207 == 0) +{ +lean_object* x_208; uint8_t x_209; +x_208 = lean_ctor_get(x_204, 0); +lean_dec(x_208); +x_209 = !lean_is_exclusive(x_206); +if (x_209 == 0) +{ +lean_object* x_210; lean_object* x_211; lean_object* x_212; +x_210 = lean_ctor_get(x_206, 0); +x_211 = lean_ctor_get(x_206, 1); +x_212 = l_Lean_parseImports_x27(x_210, x_203, x_205); +lean_dec(x_203); +lean_dec(x_210); +if (lean_obj_tag(x_212) == 0) +{ +lean_object* x_213; lean_object* x_214; +x_213 = lean_ctor_get(x_212, 0); +lean_inc(x_213); +x_214 = lean_ctor_get(x_212, 1); +lean_inc(x_214); +lean_dec(x_212); +lean_ctor_set(x_206, 0, x_213); +x_8 = x_204; +x_9 = x_214; +goto block_191; +} +else +{ +lean_object* x_215; lean_object* x_216; lean_object* x_217; uint8_t x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; +x_215 = lean_ctor_get(x_212, 0); +lean_inc(x_215); +x_216 = lean_ctor_get(x_212, 1); +lean_inc(x_216); +lean_dec(x_212); +x_217 = lean_io_error_to_string(x_215); +x_218 = 3; +x_219 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_219, 0, x_217); +lean_ctor_set_uint8(x_219, sizeof(void*)*1, x_218); +x_220 = lean_array_get_size(x_211); +x_221 = lean_array_push(x_211, x_219); +lean_ctor_set_tag(x_206, 1); +lean_ctor_set(x_206, 1, x_221); +lean_ctor_set(x_206, 0, x_220); +x_8 = x_204; +x_9 = x_216; +goto block_191; +} +} +else +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; +x_222 = lean_ctor_get(x_206, 0); +x_223 = lean_ctor_get(x_206, 1); +lean_inc(x_223); +lean_inc(x_222); +lean_dec(x_206); +x_224 = l_Lean_parseImports_x27(x_222, x_203, x_205); +lean_dec(x_203); +lean_dec(x_222); +if (lean_obj_tag(x_224) == 0) +{ +lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_225 = lean_ctor_get(x_224, 0); +lean_inc(x_225); +x_226 = lean_ctor_get(x_224, 1); +lean_inc(x_226); +lean_dec(x_224); +x_227 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_227, 0, x_225); +lean_ctor_set(x_227, 1, x_223); +lean_ctor_set(x_204, 0, x_227); +x_8 = x_204; +x_9 = x_226; +goto block_191; +} +else +{ +lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; +x_228 = lean_ctor_get(x_224, 0); +lean_inc(x_228); +x_229 = lean_ctor_get(x_224, 1); +lean_inc(x_229); +lean_dec(x_224); +x_230 = lean_io_error_to_string(x_228); +x_231 = 3; +x_232 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_232, 0, x_230); +lean_ctor_set_uint8(x_232, sizeof(void*)*1, x_231); +x_233 = lean_array_get_size(x_223); +x_234 = lean_array_push(x_223, x_232); +x_235 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_235, 0, x_233); +lean_ctor_set(x_235, 1, x_234); +lean_ctor_set(x_204, 0, x_235); +x_8 = x_204; +x_9 = x_229; +goto block_191; +} +} +} +else +{ +lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; +x_236 = lean_ctor_get(x_204, 1); +lean_inc(x_236); +lean_dec(x_204); +x_237 = lean_ctor_get(x_206, 0); +lean_inc(x_237); +x_238 = lean_ctor_get(x_206, 1); +lean_inc(x_238); +if (lean_is_exclusive(x_206)) { + lean_ctor_release(x_206, 0); + lean_ctor_release(x_206, 1); + x_239 = x_206; +} else { + lean_dec_ref(x_206); + x_239 = lean_box(0); +} +x_240 = l_Lean_parseImports_x27(x_237, x_203, x_205); +lean_dec(x_203); +lean_dec(x_237); +if (lean_obj_tag(x_240) == 0) +{ +lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_241 = lean_ctor_get(x_240, 0); +lean_inc(x_241); +x_242 = lean_ctor_get(x_240, 1); +lean_inc(x_242); +lean_dec(x_240); +if (lean_is_scalar(x_239)) { + x_243 = lean_alloc_ctor(0, 2, 0); +} else { + x_243 = x_239; +} +lean_ctor_set(x_243, 0, x_241); +lean_ctor_set(x_243, 1, x_238); +x_244 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_244, 0, x_243); +lean_ctor_set(x_244, 1, x_236); +x_8 = x_244; +x_9 = x_242; +goto block_191; +} +else +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; uint8_t x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_245 = lean_ctor_get(x_240, 0); +lean_inc(x_245); +x_246 = lean_ctor_get(x_240, 1); +lean_inc(x_246); +lean_dec(x_240); +x_247 = lean_io_error_to_string(x_245); +x_248 = 3; +x_249 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_249, 0, x_247); +lean_ctor_set_uint8(x_249, sizeof(void*)*1, x_248); +x_250 = lean_array_get_size(x_238); +x_251 = lean_array_push(x_238, x_249); +if (lean_is_scalar(x_239)) { + x_252 = lean_alloc_ctor(1, 2, 0); +} else { + x_252 = x_239; + lean_ctor_set_tag(x_252, 1); +} +lean_ctor_set(x_252, 0, x_250); +lean_ctor_set(x_252, 1, x_251); +x_253 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_236); +x_8 = x_253; +x_9 = x_246; +goto block_191; +} +} +} +else +{ +uint8_t x_254; +lean_dec(x_203); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_254 = !lean_is_exclusive(x_204); +if (x_254 == 0) +{ +lean_object* x_255; uint8_t x_256; +x_255 = lean_ctor_get(x_204, 0); +lean_dec(x_255); +x_256 = !lean_is_exclusive(x_206); +if (x_256 == 0) +{ +lean_object* x_257; +x_257 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_257, 0, x_204); +lean_ctor_set(x_257, 1, x_205); +return x_257; +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; +x_258 = lean_ctor_get(x_206, 0); +x_259 = lean_ctor_get(x_206, 1); +lean_inc(x_259); +lean_inc(x_258); +lean_dec(x_206); +x_260 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_260, 0, x_258); +lean_ctor_set(x_260, 1, x_259); +lean_ctor_set(x_204, 0, x_260); +x_261 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_261, 0, x_204); +lean_ctor_set(x_261, 1, x_205); +return x_261; +} +} +else +{ +lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +x_262 = lean_ctor_get(x_204, 1); +lean_inc(x_262); +lean_dec(x_204); +x_263 = lean_ctor_get(x_206, 0); +lean_inc(x_263); +x_264 = lean_ctor_get(x_206, 1); +lean_inc(x_264); +if (lean_is_exclusive(x_206)) { + lean_ctor_release(x_206, 0); + lean_ctor_release(x_206, 1); + x_265 = x_206; +} else { + lean_dec_ref(x_206); + x_265 = lean_box(0); +} +if (lean_is_scalar(x_265)) { + x_266 = lean_alloc_ctor(1, 2, 0); +} else { + x_266 = x_265; +} +lean_ctor_set(x_266, 0, x_263); +lean_ctor_set(x_266, 1, x_264); +x_267 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_267, 0, x_266); +lean_ctor_set(x_267, 1, x_262); +x_268 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_268, 0, x_267); +lean_ctor_set(x_268, 1, x_205); +return x_268; +} +} +} +} +} +LEAN_EXPORT lean_object* l_List_elem___at_Lake_Module_recParseImports___spec__4___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_List_elem___at_Lake_Module_recParseImports___spec__4(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_Module_recParseImports___spec__3___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lean_HashSetImp_contains___at_Lake_Module_recParseImports___spec__3(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recParseImports___spec__10___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_replace___at_Lake_Module_recParseImports___spec__10(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__1___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__1(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___lambda__2(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_2); +lean_dec(x_1); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_importsFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Module_recParseImports(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +return x_8; +} +} +static lean_object* _init_l_Lake_Module_importsFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("imports", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_importsFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_recParseImports___closed__1; +x_2 = l_Lake_Module_importsFacetConfig___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_importsFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_importsFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_importsFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_importsFacetConfig___closed__3; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_importsFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_importsFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_collectImportsAux___spec__2(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; +x_6 = lean_array_uget(x_1, x_2); +x_7 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_4, x_6); +x_8 = 1; +x_9 = lean_usize_add(x_2, x_8); +x_2 = x_9; +x_4 = x_7; +goto _start; +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(0u); +x_5 = lean_nat_dec_lt(x_4, x_3); +if (x_5 == 0) +{ +lean_dec(x_3); +return x_1; +} +else +{ +uint8_t x_6; +x_6 = lean_nat_dec_le(x_3, x_3); +if (x_6 == 0) +{ +lean_dec(x_3); +return x_1; +} +else +{ +size_t x_7; size_t x_8; lean_object* x_9; +x_7 = 0; +x_8 = lean_usize_of_nat(x_3); +lean_dec(x_3); +x_9 = l_Array_foldlMUnsafe_fold___at_Lake_collectImportsAux___spec__2(x_2, x_7, x_8, x_1); +return x_9; +} +} +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": bad import '", 14); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("'", 1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, size_t x_4, size_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +lean_object* x_13; lean_object* x_14; lean_object* x_56; lean_object* x_57; uint8_t x_101; +x_101 = lean_usize_dec_lt(x_5, x_4); +if (x_101 == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_2); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_6); +lean_ctor_set(x_102, 1, x_10); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_11); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_12); +return x_104; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_185; +x_105 = lean_array_uget(x_3, x_5); +x_106 = lean_ctor_get(x_6, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_6, 1); +lean_inc(x_107); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + lean_ctor_release(x_6, 1); + x_108 = x_6; +} else { + lean_dec_ref(x_6); + x_108 = lean_box(0); +} +lean_inc(x_2); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_105); +x_185 = lean_apply_7(x_2, x_105, x_7, x_8, x_9, x_10, x_11, x_12); +if (lean_obj_tag(x_185) == 0) +{ +lean_object* x_186; lean_object* x_187; +x_186 = lean_ctor_get(x_185, 0); +lean_inc(x_186); +x_187 = lean_ctor_get(x_186, 0); +lean_inc(x_187); +if (lean_obj_tag(x_187) == 0) +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_191; +x_188 = lean_ctor_get(x_187, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_185, 1); +lean_inc(x_189); +lean_dec(x_185); +x_190 = lean_ctor_get(x_186, 1); +lean_inc(x_190); +lean_dec(x_186); +x_191 = !lean_is_exclusive(x_187); +if (x_191 == 0) +{ +lean_object* x_192; uint8_t x_193; +x_192 = lean_ctor_get(x_187, 0); +lean_dec(x_192); +x_193 = !lean_is_exclusive(x_188); +if (x_193 == 0) +{ +lean_object* x_194; lean_object* x_195; lean_object* x_196; uint8_t x_197; +x_194 = lean_ctor_get(x_188, 0); +x_195 = lean_ctor_get(x_188, 1); +lean_inc(x_107); +x_196 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_107, x_195); +lean_dec(x_195); +x_197 = lean_unbox(x_194); +lean_dec(x_194); +if (x_197 == 0) +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; +x_198 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_198, 0, x_106); +lean_ctor_set(x_198, 1, x_196); +x_199 = lean_box(0); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_199); +lean_ctor_set(x_200, 1, x_198); +lean_ctor_set(x_187, 0, x_200); +lean_ctor_set(x_188, 1, x_190); +lean_ctor_set(x_188, 0, x_187); +x_109 = x_188; +x_110 = x_189; +goto block_184; +} +else +{ +lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; +lean_inc(x_105); +x_201 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_196, x_105); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_106); +lean_ctor_set(x_202, 1, x_201); +x_203 = lean_box(0); +x_204 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_204, 0, x_203); +lean_ctor_set(x_204, 1, x_202); +lean_ctor_set(x_187, 0, x_204); +lean_ctor_set(x_188, 1, x_190); +lean_ctor_set(x_188, 0, x_187); +x_109 = x_188; +x_110 = x_189; +goto block_184; +} +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; uint8_t x_208; +x_205 = lean_ctor_get(x_188, 0); +x_206 = lean_ctor_get(x_188, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_188); +lean_inc(x_107); +x_207 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_107, x_206); +lean_dec(x_206); +x_208 = lean_unbox(x_205); +lean_dec(x_205); +if (x_208 == 0) +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; +x_209 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_209, 0, x_106); +lean_ctor_set(x_209, 1, x_207); +x_210 = lean_box(0); +x_211 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_211, 0, x_210); +lean_ctor_set(x_211, 1, x_209); +lean_ctor_set(x_187, 0, x_211); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_187); +lean_ctor_set(x_212, 1, x_190); +x_109 = x_212; +x_110 = x_189; +goto block_184; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; +lean_inc(x_105); +x_213 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_207, x_105); +x_214 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_214, 0, x_106); +lean_ctor_set(x_214, 1, x_213); +x_215 = lean_box(0); +x_216 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_216, 0, x_215); +lean_ctor_set(x_216, 1, x_214); +lean_ctor_set(x_187, 0, x_216); +x_217 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_217, 0, x_187); +lean_ctor_set(x_217, 1, x_190); +x_109 = x_217; +x_110 = x_189; +goto block_184; +} +} +} +else +{ +lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; uint8_t x_223; +x_218 = lean_ctor_get(x_187, 1); +lean_inc(x_218); +lean_dec(x_187); +x_219 = lean_ctor_get(x_188, 0); +lean_inc(x_219); +x_220 = lean_ctor_get(x_188, 1); +lean_inc(x_220); +if (lean_is_exclusive(x_188)) { + lean_ctor_release(x_188, 0); + lean_ctor_release(x_188, 1); + x_221 = x_188; +} else { + lean_dec_ref(x_188); + x_221 = lean_box(0); +} +lean_inc(x_107); +x_222 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_107, x_220); +lean_dec(x_220); +x_223 = lean_unbox(x_219); +lean_dec(x_219); +if (x_223 == 0) +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; +x_224 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_224, 0, x_106); +lean_ctor_set(x_224, 1, x_222); +x_225 = lean_box(0); +x_226 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_224); +x_227 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_227, 0, x_226); +lean_ctor_set(x_227, 1, x_218); +if (lean_is_scalar(x_221)) { + x_228 = lean_alloc_ctor(0, 2, 0); +} else { + x_228 = x_221; +} +lean_ctor_set(x_228, 0, x_227); +lean_ctor_set(x_228, 1, x_190); +x_109 = x_228; +x_110 = x_189; +goto block_184; +} +else +{ +lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; +lean_inc(x_105); +x_229 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_222, x_105); +x_230 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_230, 0, x_106); +lean_ctor_set(x_230, 1, x_229); +x_231 = lean_box(0); +x_232 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_230); +x_233 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_233, 0, x_232); +lean_ctor_set(x_233, 1, x_218); +if (lean_is_scalar(x_221)) { + x_234 = lean_alloc_ctor(0, 2, 0); +} else { + x_234 = x_221; +} +lean_ctor_set(x_234, 0, x_233); +lean_ctor_set(x_234, 1, x_190); +x_109 = x_234; +x_110 = x_189; +goto block_184; +} +} +} +else +{ +lean_object* x_235; uint8_t x_236; +lean_dec(x_106); +x_235 = lean_ctor_get(x_185, 1); +lean_inc(x_235); +lean_dec(x_185); +x_236 = !lean_is_exclusive(x_186); +if (x_236 == 0) +{ +lean_object* x_237; uint8_t x_238; +x_237 = lean_ctor_get(x_186, 0); +lean_dec(x_237); +x_238 = !lean_is_exclusive(x_187); +if (x_238 == 0) +{ +x_109 = x_186; +x_110 = x_235; +goto block_184; +} +else +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; +x_239 = lean_ctor_get(x_187, 0); +x_240 = lean_ctor_get(x_187, 1); +lean_inc(x_240); +lean_inc(x_239); +lean_dec(x_187); +x_241 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_241, 0, x_239); +lean_ctor_set(x_241, 1, x_240); +lean_ctor_set(x_186, 0, x_241); +x_109 = x_186; +x_110 = x_235; +goto block_184; +} +} +else +{ +lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; +x_242 = lean_ctor_get(x_186, 1); +lean_inc(x_242); +lean_dec(x_186); +x_243 = lean_ctor_get(x_187, 0); +lean_inc(x_243); +x_244 = lean_ctor_get(x_187, 1); +lean_inc(x_244); +if (lean_is_exclusive(x_187)) { + lean_ctor_release(x_187, 0); + lean_ctor_release(x_187, 1); + x_245 = x_187; +} else { + lean_dec_ref(x_187); + x_245 = lean_box(0); +} +if (lean_is_scalar(x_245)) { + x_246 = lean_alloc_ctor(1, 2, 0); +} else { + x_246 = x_245; +} +lean_ctor_set(x_246, 0, x_243); +lean_ctor_set(x_246, 1, x_244); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_242); +x_109 = x_247; +x_110 = x_235; +goto block_184; +} +} +} +else +{ +uint8_t x_248; +lean_dec(x_108); +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_2); +x_248 = !lean_is_exclusive(x_185); +if (x_248 == 0) +{ +return x_185; +} +else +{ +lean_object* x_249; lean_object* x_250; lean_object* x_251; +x_249 = lean_ctor_get(x_185, 0); +x_250 = lean_ctor_get(x_185, 1); +lean_inc(x_250); +lean_inc(x_249); +lean_dec(x_185); +x_251 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_251, 0, x_249); +lean_ctor_set(x_251, 1, x_250); +return x_251; +} +} +block_184: +{ +lean_object* x_111; +x_111 = lean_ctor_get(x_109, 0); +lean_inc(x_111); +if (lean_obj_tag(x_111) == 0) +{ +uint8_t x_112; +lean_dec(x_108); +lean_dec(x_107); +lean_dec(x_105); +x_112 = !lean_is_exclusive(x_109); +if (x_112 == 0) +{ +lean_object* x_113; +x_113 = lean_ctor_get(x_109, 0); +lean_dec(x_113); +x_56 = x_109; +x_57 = x_110; +goto block_100; +} +else +{ +lean_object* x_114; lean_object* x_115; +x_114 = lean_ctor_get(x_109, 1); +lean_inc(x_114); +lean_dec(x_109); +x_115 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_115, 0, x_111); +lean_ctor_set(x_115, 1, x_114); +x_56 = x_115; +x_57 = x_110; +goto block_100; +} +} +else +{ +uint8_t x_116; +x_116 = !lean_is_exclusive(x_109); +if (x_116 == 0) +{ +lean_object* x_117; uint8_t x_118; +x_117 = lean_ctor_get(x_109, 0); +lean_dec(x_117); +x_118 = !lean_is_exclusive(x_111); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; uint8_t 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_119 = lean_ctor_get(x_111, 0); +x_120 = lean_ctor_get(x_111, 1); +x_121 = l_Array_shrink___rarg(x_120, x_119); +lean_dec(x_119); +x_122 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_123 = lean_string_append(x_122, x_1); +x_124 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_125 = lean_string_append(x_123, x_124); +x_126 = lean_ctor_get(x_105, 1); +lean_inc(x_126); +lean_dec(x_105); +x_127 = 1; +x_128 = l_Lean_Name_toString(x_126, x_127); +x_129 = lean_string_append(x_125, x_128); +lean_dec(x_128); +x_130 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_131 = lean_string_append(x_129, x_130); +x_132 = 3; +x_133 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_133, 0, x_131); +lean_ctor_set_uint8(x_133, sizeof(void*)*1, x_132); +x_134 = lean_array_push(x_121, x_133); +x_135 = lean_box(x_127); +if (lean_is_scalar(x_108)) { + x_136 = lean_alloc_ctor(0, 2, 0); +} else { + x_136 = x_108; +} +lean_ctor_set(x_136, 0, x_135); +lean_ctor_set(x_136, 1, x_107); +x_137 = lean_box(0); +x_138 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_138, 0, x_137); +lean_ctor_set(x_138, 1, x_136); +lean_ctor_set_tag(x_111, 0); +lean_ctor_set(x_111, 1, x_134); +lean_ctor_set(x_111, 0, x_138); +x_56 = x_109; +x_57 = x_110; +goto block_100; +} +else +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; uint8_t x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; +x_139 = lean_ctor_get(x_111, 0); +x_140 = lean_ctor_get(x_111, 1); +lean_inc(x_140); +lean_inc(x_139); +lean_dec(x_111); +x_141 = l_Array_shrink___rarg(x_140, x_139); +lean_dec(x_139); +x_142 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_143 = lean_string_append(x_142, x_1); +x_144 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_145 = lean_string_append(x_143, x_144); +x_146 = lean_ctor_get(x_105, 1); +lean_inc(x_146); +lean_dec(x_105); +x_147 = 1; +x_148 = l_Lean_Name_toString(x_146, x_147); +x_149 = lean_string_append(x_145, x_148); +lean_dec(x_148); +x_150 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_151 = lean_string_append(x_149, x_150); +x_152 = 3; +x_153 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_153, 0, x_151); +lean_ctor_set_uint8(x_153, sizeof(void*)*1, x_152); +x_154 = lean_array_push(x_141, x_153); +x_155 = lean_box(x_147); +if (lean_is_scalar(x_108)) { + x_156 = lean_alloc_ctor(0, 2, 0); +} else { + x_156 = x_108; +} +lean_ctor_set(x_156, 0, x_155); +lean_ctor_set(x_156, 1, x_107); +x_157 = lean_box(0); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_157); +lean_ctor_set(x_158, 1, x_156); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_154); +lean_ctor_set(x_109, 0, x_159); +x_56 = x_109; +x_57 = x_110; +goto block_100; +} +} +else +{ +lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_160 = lean_ctor_get(x_109, 1); +lean_inc(x_160); +lean_dec(x_109); +x_161 = lean_ctor_get(x_111, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_111, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_111)) { + lean_ctor_release(x_111, 0); + lean_ctor_release(x_111, 1); + x_163 = x_111; +} else { + lean_dec_ref(x_111); + x_163 = lean_box(0); +} +x_164 = l_Array_shrink___rarg(x_162, x_161); +lean_dec(x_161); +x_165 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_166 = lean_string_append(x_165, x_1); +x_167 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_168 = lean_string_append(x_166, x_167); +x_169 = lean_ctor_get(x_105, 1); +lean_inc(x_169); +lean_dec(x_105); +x_170 = 1; +x_171 = l_Lean_Name_toString(x_169, x_170); +x_172 = lean_string_append(x_168, x_171); +lean_dec(x_171); +x_173 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_174 = lean_string_append(x_172, x_173); +x_175 = 3; +x_176 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_176, 0, x_174); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_175); +x_177 = lean_array_push(x_164, x_176); +x_178 = lean_box(x_170); +if (lean_is_scalar(x_108)) { + x_179 = lean_alloc_ctor(0, 2, 0); +} else { + x_179 = x_108; +} +lean_ctor_set(x_179, 0, x_178); +lean_ctor_set(x_179, 1, x_107); +x_180 = lean_box(0); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_179); +if (lean_is_scalar(x_163)) { + x_182 = lean_alloc_ctor(0, 2, 0); +} else { + x_182 = x_163; + lean_ctor_set_tag(x_182, 0); +} +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_177); +x_183 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_160); +x_56 = x_183; +x_57 = x_110; +goto block_100; +} +} +} +} +block_55: +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_13, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_2); +x_17 = !lean_is_exclusive(x_13); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_ctor_get(x_13, 0); +lean_dec(x_18); +x_19 = !lean_is_exclusive(x_15); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_15, 0); +lean_dec(x_20); +x_21 = lean_ctor_get(x_16, 0); +lean_inc(x_21); +lean_dec(x_16); +lean_ctor_set(x_15, 0, x_21); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_13); +lean_ctor_set(x_22, 1, x_14); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_15, 1); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_ctor_get(x_16, 0); +lean_inc(x_24); +lean_dec(x_16); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_23); +lean_ctor_set(x_13, 0, x_25); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_13); +lean_ctor_set(x_26, 1, x_14); +return x_26; +} +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_27 = lean_ctor_get(x_13, 1); +lean_inc(x_27); +lean_dec(x_13); +x_28 = lean_ctor_get(x_15, 1); +lean_inc(x_28); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_29 = x_15; +} else { + lean_dec_ref(x_15); + x_29 = lean_box(0); +} +x_30 = lean_ctor_get(x_16, 0); +lean_inc(x_30); +lean_dec(x_16); +if (lean_is_scalar(x_29)) { + x_31 = lean_alloc_ctor(0, 2, 0); +} else { + x_31 = x_29; +} +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_28); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_27); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_14); +return x_33; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; size_t x_37; size_t x_38; +x_34 = lean_ctor_get(x_13, 1); +lean_inc(x_34); +lean_dec(x_13); +x_35 = lean_ctor_get(x_15, 1); +lean_inc(x_35); +lean_dec(x_15); +x_36 = lean_ctor_get(x_16, 0); +lean_inc(x_36); +lean_dec(x_16); +x_37 = 1; +x_38 = lean_usize_add(x_5, x_37); +x_5 = x_38; +x_6 = x_36; +x_10 = x_35; +x_11 = x_34; +x_12 = x_14; +goto _start; +} +} +else +{ +uint8_t x_40; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_2); +x_40 = !lean_is_exclusive(x_13); +if (x_40 == 0) +{ +lean_object* x_41; uint8_t x_42; +x_41 = lean_ctor_get(x_13, 0); +lean_dec(x_41); +x_42 = !lean_is_exclusive(x_15); +if (x_42 == 0) +{ +lean_object* x_43; +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_13); +lean_ctor_set(x_43, 1, x_14); +return x_43; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_44 = lean_ctor_get(x_15, 0); +x_45 = lean_ctor_get(x_15, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_15); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +lean_ctor_set(x_13, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_13); +lean_ctor_set(x_47, 1, x_14); +return x_47; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_48 = lean_ctor_get(x_13, 1); +lean_inc(x_48); +lean_dec(x_13); +x_49 = lean_ctor_get(x_15, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_15, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_51 = x_15; +} else { + lean_dec_ref(x_15); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_14); +return x_54; +} +} +} +block_100: +{ +lean_object* x_58; +x_58 = lean_ctor_get(x_56, 0); +lean_inc(x_58); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; uint8_t x_61; +x_59 = lean_ctor_get(x_58, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_59, 1); +lean_inc(x_60); +lean_dec(x_59); +x_61 = !lean_is_exclusive(x_56); +if (x_61 == 0) +{ +lean_object* x_62; uint8_t x_63; +x_62 = lean_ctor_get(x_56, 0); +lean_dec(x_62); +x_63 = !lean_is_exclusive(x_58); +if (x_63 == 0) +{ +lean_object* x_64; uint8_t x_65; +x_64 = lean_ctor_get(x_58, 0); +lean_dec(x_64); +x_65 = !lean_is_exclusive(x_60); +if (x_65 == 0) +{ +lean_object* x_66; +x_66 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_66, 0, x_60); +lean_ctor_set(x_58, 0, x_66); +x_13 = x_56; +x_14 = x_57; +goto block_55; +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_67 = lean_ctor_get(x_60, 0); +x_68 = lean_ctor_get(x_60, 1); +lean_inc(x_68); +lean_inc(x_67); +lean_dec(x_60); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_67); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_58, 0, x_70); +x_13 = x_56; +x_14 = x_57; +goto block_55; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_71 = lean_ctor_get(x_58, 1); +lean_inc(x_71); +lean_dec(x_58); +x_72 = lean_ctor_get(x_60, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_60, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_60)) { + lean_ctor_release(x_60, 0); + lean_ctor_release(x_60, 1); + x_74 = x_60; +} else { + lean_dec_ref(x_60); + x_74 = lean_box(0); +} +if (lean_is_scalar(x_74)) { + x_75 = lean_alloc_ctor(0, 2, 0); +} else { + x_75 = x_74; +} +lean_ctor_set(x_75, 0, x_72); +lean_ctor_set(x_75, 1, x_73); +x_76 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_76, 0, x_75); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_71); +lean_ctor_set(x_56, 0, x_77); +x_13 = x_56; +x_14 = x_57; +goto block_55; +} +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_78 = lean_ctor_get(x_56, 1); +lean_inc(x_78); +lean_dec(x_56); +x_79 = lean_ctor_get(x_58, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_58)) { + lean_ctor_release(x_58, 0); + lean_ctor_release(x_58, 1); + x_80 = x_58; +} else { + lean_dec_ref(x_58); + x_80 = lean_box(0); +} +x_81 = lean_ctor_get(x_60, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_60, 1); +lean_inc(x_82); +if (lean_is_exclusive(x_60)) { + lean_ctor_release(x_60, 0); + lean_ctor_release(x_60, 1); + x_83 = x_60; +} else { + lean_dec_ref(x_60); + x_83 = lean_box(0); +} +if (lean_is_scalar(x_83)) { + x_84 = lean_alloc_ctor(0, 2, 0); +} else { + x_84 = x_83; +} +lean_ctor_set(x_84, 0, x_81); +lean_ctor_set(x_84, 1, x_82); +x_85 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_85, 0, x_84); +if (lean_is_scalar(x_80)) { + x_86 = lean_alloc_ctor(0, 2, 0); +} else { + x_86 = x_80; +} +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_79); +x_87 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +x_13 = x_87; +x_14 = x_57; +goto block_55; +} +} +else +{ +uint8_t x_88; +x_88 = !lean_is_exclusive(x_56); +if (x_88 == 0) +{ +lean_object* x_89; uint8_t x_90; +x_89 = lean_ctor_get(x_56, 0); +lean_dec(x_89); +x_90 = !lean_is_exclusive(x_58); +if (x_90 == 0) +{ +x_13 = x_56; +x_14 = x_57; +goto block_55; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_91 = lean_ctor_get(x_58, 0); +x_92 = lean_ctor_get(x_58, 1); +lean_inc(x_92); +lean_inc(x_91); +lean_dec(x_58); +x_93 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_93, 0, x_91); +lean_ctor_set(x_93, 1, x_92); +lean_ctor_set(x_56, 0, x_93); +x_13 = x_56; +x_14 = x_57; +goto block_55; +} +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_94 = lean_ctor_get(x_56, 1); +lean_inc(x_94); +lean_dec(x_56); +x_95 = lean_ctor_get(x_58, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_58, 1); +lean_inc(x_96); +if (lean_is_exclusive(x_58)) { + lean_ctor_release(x_58, 0); + lean_ctor_release(x_58, 1); + x_97 = x_58; +} else { + lean_dec_ref(x_58); + x_97 = lean_box(0); +} +if (lean_is_scalar(x_97)) { + x_98 = lean_alloc_ctor(1, 2, 0); +} else { + x_98 = x_97; +} +lean_ctor_set(x_98, 0, x_95); +lean_ctor_set(x_98, 1, x_96); +x_99 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_99, 0, x_98); +lean_ctor_set(x_99, 1, x_94); +x_13 = x_99; +x_14 = x_57; +goto block_55; +} +} +} +} +} +static lean_object* _init_l_Lake_collectImportsAux___closed__1() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = 0; +x_2 = l_Lake_OrdHashSet_empty___at_Lake_OrdModuleSet_empty___spec__1; +x_3 = lean_box(x_1); +x_4 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_4, 0, x_3); +lean_ctor_set(x_4, 1, x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_collectImportsAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; size_t x_11; size_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_38; lean_object* x_39; +x_10 = lean_array_get_size(x_2); +x_11 = lean_usize_of_nat(x_10); +lean_dec(x_10); +x_12 = 0; +x_13 = lean_array_get_size(x_7); +x_38 = l_Lake_collectImportsAux___closed__1; +x_39 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3(x_1, x_3, x_2, x_11, x_12, x_38, x_4, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_39) == 0) +{ +lean_object* x_40; lean_object* x_41; +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_40, 0); +lean_inc(x_41); +if (lean_obj_tag(x_41) == 0) +{ +lean_object* x_42; lean_object* x_43; uint8_t x_44; +x_42 = lean_ctor_get(x_41, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_unbox(x_43); +lean_dec(x_43); +if (x_44 == 0) +{ +lean_object* x_45; uint8_t x_46; +x_45 = lean_ctor_get(x_39, 1); +lean_inc(x_45); +lean_dec(x_39); +x_46 = !lean_is_exclusive(x_40); +if (x_46 == 0) +{ +lean_object* x_47; uint8_t x_48; +x_47 = lean_ctor_get(x_40, 0); +lean_dec(x_47); +x_48 = !lean_is_exclusive(x_41); +if (x_48 == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_41, 0); +lean_dec(x_49); +x_50 = lean_ctor_get(x_42, 1); +lean_inc(x_50); +lean_dec(x_42); +x_51 = lean_ctor_get(x_50, 1); +lean_inc(x_51); +lean_dec(x_50); +lean_ctor_set(x_41, 0, x_51); +x_14 = x_40; +x_15 = x_45; +goto block_37; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_41, 1); +lean_inc(x_52); +lean_dec(x_41); +x_53 = lean_ctor_get(x_42, 1); +lean_inc(x_53); +lean_dec(x_42); +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_52); +lean_ctor_set(x_40, 0, x_55); +x_14 = x_40; +x_15 = x_45; +goto block_37; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_56 = lean_ctor_get(x_40, 1); +lean_inc(x_56); +lean_dec(x_40); +x_57 = lean_ctor_get(x_41, 1); +lean_inc(x_57); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_58 = x_41; +} else { + lean_dec_ref(x_41); + x_58 = lean_box(0); +} +x_59 = lean_ctor_get(x_42, 1); +lean_inc(x_59); +lean_dec(x_42); +x_60 = lean_ctor_get(x_59, 1); +lean_inc(x_60); +lean_dec(x_59); +if (lean_is_scalar(x_58)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_58; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_57); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_56); +x_14 = x_62; +x_15 = x_45; +goto block_37; +} +} +else +{ +lean_object* x_63; uint8_t x_64; +lean_dec(x_42); +x_63 = lean_ctor_get(x_39, 1); +lean_inc(x_63); +lean_dec(x_39); +x_64 = !lean_is_exclusive(x_40); +if (x_64 == 0) +{ +lean_object* x_65; uint8_t x_66; +x_65 = lean_ctor_get(x_40, 0); +lean_dec(x_65); +x_66 = !lean_is_exclusive(x_41); +if (x_66 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_41, 1); +x_68 = lean_ctor_get(x_41, 0); +lean_dec(x_68); +x_69 = lean_array_get_size(x_67); +lean_ctor_set_tag(x_41, 1); +lean_ctor_set(x_41, 0, x_69); +x_14 = x_40; +x_15 = x_63; +goto block_37; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_41, 1); +lean_inc(x_70); +lean_dec(x_41); +x_71 = lean_array_get_size(x_70); +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_70); +lean_ctor_set(x_40, 0, x_72); +x_14 = x_40; +x_15 = x_63; +goto block_37; +} +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_73 = lean_ctor_get(x_40, 1); +lean_inc(x_73); +lean_dec(x_40); +x_74 = lean_ctor_get(x_41, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_75 = x_41; +} else { + lean_dec_ref(x_41); + x_75 = lean_box(0); +} +x_76 = lean_array_get_size(x_74); +if (lean_is_scalar(x_75)) { + x_77 = lean_alloc_ctor(1, 2, 0); +} else { + x_77 = x_75; + lean_ctor_set_tag(x_77, 1); +} +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_74); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_73); +x_14 = x_78; +x_15 = x_63; +goto block_37; +} +} +} +else +{ +lean_object* x_79; uint8_t x_80; +x_79 = lean_ctor_get(x_39, 1); +lean_inc(x_79); +lean_dec(x_39); +x_80 = !lean_is_exclusive(x_40); +if (x_80 == 0) +{ +lean_object* x_81; uint8_t x_82; +x_81 = lean_ctor_get(x_40, 0); +lean_dec(x_81); +x_82 = !lean_is_exclusive(x_41); +if (x_82 == 0) +{ +x_14 = x_40; +x_15 = x_79; +goto block_37; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_83 = lean_ctor_get(x_41, 0); +x_84 = lean_ctor_get(x_41, 1); +lean_inc(x_84); +lean_inc(x_83); +lean_dec(x_41); +x_85 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_85, 0, x_83); +lean_ctor_set(x_85, 1, x_84); +lean_ctor_set(x_40, 0, x_85); +x_14 = x_40; +x_15 = x_79; +goto block_37; +} +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_86 = lean_ctor_get(x_40, 1); +lean_inc(x_86); +lean_dec(x_40); +x_87 = lean_ctor_get(x_41, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_41, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_41)) { + lean_ctor_release(x_41, 0); + lean_ctor_release(x_41, 1); + x_89 = x_41; +} else { + lean_dec_ref(x_41); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +x_91 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_86); +x_14 = x_91; +x_15 = x_79; +goto block_37; +} +} +} +else +{ +uint8_t x_92; +lean_dec(x_13); +x_92 = !lean_is_exclusive(x_39); +if (x_92 == 0) +{ +return x_39; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_93 = lean_ctor_get(x_39, 0); +x_94 = lean_ctor_get(x_39, 1); +lean_inc(x_94); +lean_inc(x_93); +lean_dec(x_39); +x_95 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_95, 0, x_93); +lean_ctor_set(x_95, 1, x_94); +return x_95; +} +} +block_37: +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_14, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +lean_dec(x_13); +x_17 = !lean_is_exclusive(x_14); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; +x_18 = lean_ctor_get(x_14, 0); +lean_dec(x_18); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_14); +lean_ctor_set(x_19, 1, x_15); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_14, 1); +lean_inc(x_20); +lean_dec(x_14); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_16); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_15); +return x_22; +} +} +else +{ +uint8_t x_23; +x_23 = !lean_is_exclusive(x_14); +if (x_23 == 0) +{ +lean_object* x_24; uint8_t x_25; +x_24 = lean_ctor_get(x_14, 0); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_16); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_16, 0); +lean_dec(x_26); +lean_ctor_set(x_16, 0, x_13); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_14); +lean_ctor_set(x_27, 1, x_15); +return x_27; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_16, 1); +lean_inc(x_28); +lean_dec(x_16); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_13); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_14, 0, x_29); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_14); +lean_ctor_set(x_30, 1, x_15); +return x_30; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_31 = lean_ctor_get(x_14, 1); +lean_inc(x_31); +lean_dec(x_14); +x_32 = lean_ctor_get(x_16, 1); +lean_inc(x_32); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_33 = x_16; +} else { + lean_dec_ref(x_16); + x_33 = lean_box(0); +} +if (lean_is_scalar(x_33)) { + x_34 = lean_alloc_ctor(1, 2, 0); +} else { + x_34 = x_33; +} +lean_ctor_set(x_34, 0, x_13); +lean_ctor_set(x_34, 1, x_32); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_31); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_15); +return x_36; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_collectImportsAux___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_collectImportsAux___spec__2(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +size_t x_13; size_t x_14; lean_object* x_15; +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_15 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3(x_1, x_2, x_3, x_13, x_14, x_6, x_7, x_8, x_9, x_10, x_11, x_12); +lean_dec(x_3); +lean_dec(x_1); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Lake_collectImportsAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_collectImportsAux(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_2); +lean_dec(x_1); +return x_10; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("transImports", 12); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_recParseImports___closed__1; +x_2 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_55; lean_object* x_56; uint8_t x_100; +x_100 = lean_usize_dec_lt(x_4, x_3); +if (x_100 == 0) +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_5); +lean_ctor_set(x_101, 1, x_9); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_10); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_11); +return x_103; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_184; lean_object* x_185; lean_object* x_246; lean_object* x_247; lean_object* x_248; +x_104 = lean_array_uget(x_2, x_4); +x_105 = lean_ctor_get(x_5, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_5, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_107 = x_5; +} else { + lean_dec_ref(x_5); + x_107 = lean_box(0); +} +x_246 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +lean_inc(x_104); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_104); +lean_ctor_set(x_247, 1, x_246); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_248 = lean_apply_6(x_6, x_247, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_248) == 0) +{ +lean_object* x_249; lean_object* x_250; +x_249 = lean_ctor_get(x_248, 0); +lean_inc(x_249); +x_250 = lean_ctor_get(x_249, 0); +lean_inc(x_250); +if (lean_obj_tag(x_250) == 0) +{ +lean_object* x_251; uint8_t x_252; +x_251 = lean_ctor_get(x_248, 1); +lean_inc(x_251); +lean_dec(x_248); +x_252 = !lean_is_exclusive(x_249); +if (x_252 == 0) +{ +lean_object* x_253; lean_object* x_254; uint8_t x_255; +x_253 = lean_ctor_get(x_249, 1); +x_254 = lean_ctor_get(x_249, 0); +lean_dec(x_254); +x_255 = !lean_is_exclusive(x_250); +if (x_255 == 0) +{ +lean_object* x_256; uint8_t x_257; lean_object* x_258; lean_object* x_259; +x_256 = lean_ctor_get(x_250, 0); +x_257 = 1; +x_258 = lean_box(x_257); +lean_ctor_set(x_249, 1, x_256); +lean_ctor_set(x_249, 0, x_258); +lean_ctor_set(x_250, 0, x_249); +x_259 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_259, 0, x_250); +lean_ctor_set(x_259, 1, x_253); +x_184 = x_259; +x_185 = x_251; +goto block_245; +} +else +{ +lean_object* x_260; lean_object* x_261; uint8_t x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; +x_260 = lean_ctor_get(x_250, 0); +x_261 = lean_ctor_get(x_250, 1); +lean_inc(x_261); +lean_inc(x_260); +lean_dec(x_250); +x_262 = 1; +x_263 = lean_box(x_262); +lean_ctor_set(x_249, 1, x_260); +lean_ctor_set(x_249, 0, x_263); +x_264 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_264, 0, x_249); +lean_ctor_set(x_264, 1, x_261); +x_265 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_265, 0, x_264); +lean_ctor_set(x_265, 1, x_253); +x_184 = x_265; +x_185 = x_251; +goto block_245; +} +} +else +{ +lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; +x_266 = lean_ctor_get(x_249, 1); +lean_inc(x_266); +lean_dec(x_249); +x_267 = lean_ctor_get(x_250, 0); +lean_inc(x_267); +x_268 = lean_ctor_get(x_250, 1); +lean_inc(x_268); +if (lean_is_exclusive(x_250)) { + lean_ctor_release(x_250, 0); + lean_ctor_release(x_250, 1); + x_269 = x_250; +} else { + lean_dec_ref(x_250); + x_269 = lean_box(0); +} +x_270 = 1; +x_271 = lean_box(x_270); +x_272 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_272, 0, x_271); +lean_ctor_set(x_272, 1, x_267); +if (lean_is_scalar(x_269)) { + x_273 = lean_alloc_ctor(0, 2, 0); +} else { + x_273 = x_269; +} +lean_ctor_set(x_273, 0, x_272); +lean_ctor_set(x_273, 1, x_268); +x_274 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_274, 0, x_273); +lean_ctor_set(x_274, 1, x_266); +x_184 = x_274; +x_185 = x_251; +goto block_245; +} +} +else +{ +lean_object* x_275; uint8_t x_276; +x_275 = lean_ctor_get(x_248, 1); +lean_inc(x_275); +lean_dec(x_248); +x_276 = !lean_is_exclusive(x_249); +if (x_276 == 0) +{ +lean_object* x_277; uint8_t x_278; +x_277 = lean_ctor_get(x_249, 0); +lean_dec(x_277); +x_278 = !lean_is_exclusive(x_250); +if (x_278 == 0) +{ +x_184 = x_249; +x_185 = x_275; +goto block_245; +} +else +{ +lean_object* x_279; lean_object* x_280; lean_object* x_281; +x_279 = lean_ctor_get(x_250, 0); +x_280 = lean_ctor_get(x_250, 1); +lean_inc(x_280); +lean_inc(x_279); +lean_dec(x_250); +x_281 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_281, 0, x_279); +lean_ctor_set(x_281, 1, x_280); +lean_ctor_set(x_249, 0, x_281); +x_184 = x_249; +x_185 = x_275; +goto block_245; +} +} +else +{ +lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; +x_282 = lean_ctor_get(x_249, 1); +lean_inc(x_282); +lean_dec(x_249); +x_283 = lean_ctor_get(x_250, 0); +lean_inc(x_283); +x_284 = lean_ctor_get(x_250, 1); +lean_inc(x_284); +if (lean_is_exclusive(x_250)) { + lean_ctor_release(x_250, 0); + lean_ctor_release(x_250, 1); + x_285 = x_250; +} else { + lean_dec_ref(x_250); + x_285 = lean_box(0); +} +if (lean_is_scalar(x_285)) { + x_286 = lean_alloc_ctor(1, 2, 0); +} else { + x_286 = x_285; +} +lean_ctor_set(x_286, 0, x_283); +lean_ctor_set(x_286, 1, x_284); +x_287 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_287, 0, x_286); +lean_ctor_set(x_287, 1, x_282); +x_184 = x_287; +x_185 = x_275; +goto block_245; +} +} +} +else +{ +uint8_t x_288; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_288 = !lean_is_exclusive(x_248); +if (x_288 == 0) +{ +return x_248; +} +else +{ +lean_object* x_289; lean_object* x_290; lean_object* x_291; +x_289 = lean_ctor_get(x_248, 0); +x_290 = lean_ctor_get(x_248, 1); +lean_inc(x_290); +lean_inc(x_289); +lean_dec(x_248); +x_291 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_291, 0, x_289); +lean_ctor_set(x_291, 1, x_290); +return x_291; +} +} +block_183: +{ +lean_object* x_110; +x_110 = lean_ctor_get(x_108, 0); +lean_inc(x_110); +if (lean_obj_tag(x_110) == 0) +{ +uint8_t x_111; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_104); +x_111 = !lean_is_exclusive(x_108); +if (x_111 == 0) +{ +lean_object* x_112; +x_112 = lean_ctor_get(x_108, 0); +lean_dec(x_112); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_113; lean_object* x_114; +x_113 = lean_ctor_get(x_108, 1); +lean_inc(x_113); +lean_dec(x_108); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_110); +lean_ctor_set(x_114, 1, x_113); +x_55 = x_114; +x_56 = x_109; +goto block_99; +} +} +else +{ +uint8_t x_115; +x_115 = !lean_is_exclusive(x_108); +if (x_115 == 0) +{ +lean_object* x_116; uint8_t x_117; +x_116 = lean_ctor_get(x_108, 0); +lean_dec(x_116); +x_117 = !lean_is_exclusive(x_110); +if (x_117 == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_118 = lean_ctor_get(x_110, 0); +x_119 = lean_ctor_get(x_110, 1); +x_120 = l_Array_shrink___rarg(x_119, x_118); +lean_dec(x_118); +x_121 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_122 = lean_string_append(x_121, x_1); +x_123 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_124 = lean_string_append(x_122, x_123); +x_125 = lean_ctor_get(x_104, 1); +lean_inc(x_125); +lean_dec(x_104); +x_126 = 1; +x_127 = l_Lean_Name_toString(x_125, x_126); +x_128 = lean_string_append(x_124, x_127); +lean_dec(x_127); +x_129 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_130 = lean_string_append(x_128, x_129); +x_131 = 3; +x_132 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set_uint8(x_132, sizeof(void*)*1, x_131); +x_133 = lean_array_push(x_120, x_132); +x_134 = lean_box(x_126); +if (lean_is_scalar(x_107)) { + x_135 = lean_alloc_ctor(0, 2, 0); +} else { + x_135 = x_107; +} +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_106); +x_136 = lean_box(0); +x_137 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_135); +lean_ctor_set_tag(x_110, 0); +lean_ctor_set(x_110, 1, x_133); +lean_ctor_set(x_110, 0, x_137); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +x_138 = lean_ctor_get(x_110, 0); +x_139 = lean_ctor_get(x_110, 1); +lean_inc(x_139); +lean_inc(x_138); +lean_dec(x_110); +x_140 = l_Array_shrink___rarg(x_139, x_138); +lean_dec(x_138); +x_141 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_142 = lean_string_append(x_141, x_1); +x_143 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_144 = lean_string_append(x_142, x_143); +x_145 = lean_ctor_get(x_104, 1); +lean_inc(x_145); +lean_dec(x_104); +x_146 = 1; +x_147 = l_Lean_Name_toString(x_145, x_146); +x_148 = lean_string_append(x_144, x_147); +lean_dec(x_147); +x_149 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_150 = lean_string_append(x_148, x_149); +x_151 = 3; +x_152 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set_uint8(x_152, sizeof(void*)*1, x_151); +x_153 = lean_array_push(x_140, x_152); +x_154 = lean_box(x_146); +if (lean_is_scalar(x_107)) { + x_155 = lean_alloc_ctor(0, 2, 0); +} else { + x_155 = x_107; +} +lean_ctor_set(x_155, 0, x_154); +lean_ctor_set(x_155, 1, x_106); +x_156 = lean_box(0); +x_157 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_157, 0, x_156); +lean_ctor_set(x_157, 1, x_155); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_157); +lean_ctor_set(x_158, 1, x_153); +lean_ctor_set(x_108, 0, x_158); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; uint8_t x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; +x_159 = lean_ctor_get(x_108, 1); +lean_inc(x_159); +lean_dec(x_108); +x_160 = lean_ctor_get(x_110, 0); +lean_inc(x_160); +x_161 = lean_ctor_get(x_110, 1); +lean_inc(x_161); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_162 = x_110; +} else { + lean_dec_ref(x_110); + x_162 = lean_box(0); +} +x_163 = l_Array_shrink___rarg(x_161, x_160); +lean_dec(x_160); +x_164 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_165 = lean_string_append(x_164, x_1); +x_166 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_167 = lean_string_append(x_165, x_166); +x_168 = lean_ctor_get(x_104, 1); +lean_inc(x_168); +lean_dec(x_104); +x_169 = 1; +x_170 = l_Lean_Name_toString(x_168, x_169); +x_171 = lean_string_append(x_167, x_170); +lean_dec(x_170); +x_172 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_173 = lean_string_append(x_171, x_172); +x_174 = 3; +x_175 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_175, 0, x_173); +lean_ctor_set_uint8(x_175, sizeof(void*)*1, x_174); +x_176 = lean_array_push(x_163, x_175); +x_177 = lean_box(x_169); +if (lean_is_scalar(x_107)) { + x_178 = lean_alloc_ctor(0, 2, 0); +} else { + x_178 = x_107; +} +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_106); +x_179 = lean_box(0); +x_180 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_178); +if (lean_is_scalar(x_162)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_162; + lean_ctor_set_tag(x_181, 0); +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_176); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_159); +x_55 = x_182; +x_56 = x_109; +goto block_99; +} +} +} +block_245: +{ +lean_object* x_186; +x_186 = lean_ctor_get(x_184, 0); +lean_inc(x_186); +if (lean_obj_tag(x_186) == 0) +{ +lean_object* x_187; lean_object* x_188; uint8_t x_189; +x_187 = lean_ctor_get(x_186, 0); +lean_inc(x_187); +x_188 = lean_ctor_get(x_184, 1); +lean_inc(x_188); +lean_dec(x_184); +x_189 = !lean_is_exclusive(x_186); +if (x_189 == 0) +{ +lean_object* x_190; uint8_t x_191; +x_190 = lean_ctor_get(x_186, 0); +lean_dec(x_190); +x_191 = !lean_is_exclusive(x_187); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; +x_192 = lean_ctor_get(x_187, 0); +x_193 = lean_ctor_get(x_187, 1); +lean_inc(x_106); +x_194 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_193); +lean_dec(x_193); +x_195 = lean_unbox(x_192); +lean_dec(x_192); +if (x_195 == 0) +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; +x_196 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_196, 0, x_105); +lean_ctor_set(x_196, 1, x_194); +x_197 = lean_box(0); +x_198 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_196); +lean_ctor_set(x_186, 0, x_198); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; +lean_inc(x_104); +x_199 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_194, x_104); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_105); +lean_ctor_set(x_200, 1, x_199); +x_201 = lean_box(0); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_201); +lean_ctor_set(x_202, 1, x_200); +lean_ctor_set(x_186, 0, x_202); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_203; lean_object* x_204; lean_object* x_205; uint8_t x_206; +x_203 = lean_ctor_get(x_187, 0); +x_204 = lean_ctor_get(x_187, 1); +lean_inc(x_204); +lean_inc(x_203); +lean_dec(x_187); +lean_inc(x_106); +x_205 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_204); +lean_dec(x_204); +x_206 = lean_unbox(x_203); +lean_dec(x_203); +if (x_206 == 0) +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +x_207 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_207, 0, x_105); +lean_ctor_set(x_207, 1, x_205); +x_208 = lean_box(0); +x_209 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_209, 0, x_208); +lean_ctor_set(x_209, 1, x_207); +lean_ctor_set(x_186, 0, x_209); +x_210 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_210, 0, x_186); +lean_ctor_set(x_210, 1, x_188); +x_108 = x_210; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +lean_inc(x_104); +x_211 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_205, x_104); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_105); +lean_ctor_set(x_212, 1, x_211); +x_213 = lean_box(0); +x_214 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_214, 0, x_213); +lean_ctor_set(x_214, 1, x_212); +lean_ctor_set(x_186, 0, x_214); +x_215 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_215, 0, x_186); +lean_ctor_set(x_215, 1, x_188); +x_108 = x_215; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; uint8_t x_221; +x_216 = lean_ctor_get(x_186, 1); +lean_inc(x_216); +lean_dec(x_186); +x_217 = lean_ctor_get(x_187, 0); +lean_inc(x_217); +x_218 = lean_ctor_get(x_187, 1); +lean_inc(x_218); +if (lean_is_exclusive(x_187)) { + lean_ctor_release(x_187, 0); + lean_ctor_release(x_187, 1); + x_219 = x_187; +} else { + lean_dec_ref(x_187); + x_219 = lean_box(0); +} +lean_inc(x_106); +x_220 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_218); +lean_dec(x_218); +x_221 = lean_unbox(x_217); +lean_dec(x_217); +if (x_221 == 0) +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_222 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_222, 0, x_105); +lean_ctor_set(x_222, 1, x_220); +x_223 = lean_box(0); +x_224 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_224, 0, x_223); +lean_ctor_set(x_224, 1, x_222); +x_225 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_225, 0, x_224); +lean_ctor_set(x_225, 1, x_216); +if (lean_is_scalar(x_219)) { + x_226 = lean_alloc_ctor(0, 2, 0); +} else { + x_226 = x_219; +} +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_188); +x_108 = x_226; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +lean_inc(x_104); +x_227 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_220, x_104); +x_228 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_228, 0, x_105); +lean_ctor_set(x_228, 1, x_227); +x_229 = lean_box(0); +x_230 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_230, 0, x_229); +lean_ctor_set(x_230, 1, x_228); +x_231 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_231, 0, x_230); +lean_ctor_set(x_231, 1, x_216); +if (lean_is_scalar(x_219)) { + x_232 = lean_alloc_ctor(0, 2, 0); +} else { + x_232 = x_219; +} +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_188); +x_108 = x_232; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +uint8_t x_233; +lean_dec(x_105); +x_233 = !lean_is_exclusive(x_184); +if (x_233 == 0) +{ +lean_object* x_234; uint8_t x_235; +x_234 = lean_ctor_get(x_184, 0); +lean_dec(x_234); +x_235 = !lean_is_exclusive(x_186); +if (x_235 == 0) +{ +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_236; lean_object* x_237; lean_object* x_238; +x_236 = lean_ctor_get(x_186, 0); +x_237 = lean_ctor_get(x_186, 1); +lean_inc(x_237); +lean_inc(x_236); +lean_dec(x_186); +x_238 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_238, 0, x_236); +lean_ctor_set(x_238, 1, x_237); +lean_ctor_set(x_184, 0, x_238); +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_239 = lean_ctor_get(x_184, 1); +lean_inc(x_239); +lean_dec(x_184); +x_240 = lean_ctor_get(x_186, 0); +lean_inc(x_240); +x_241 = lean_ctor_get(x_186, 1); +lean_inc(x_241); +if (lean_is_exclusive(x_186)) { + lean_ctor_release(x_186, 0); + lean_ctor_release(x_186, 1); + x_242 = x_186; +} else { + lean_dec_ref(x_186); + x_242 = lean_box(0); +} +if (lean_is_scalar(x_242)) { + x_243 = lean_alloc_ctor(1, 2, 0); +} else { + x_243 = x_242; +} +lean_ctor_set(x_243, 0, x_240); +lean_ctor_set(x_243, 1, x_241); +x_244 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_244, 0, x_243); +lean_ctor_set(x_244, 1, x_239); +x_108 = x_244; +x_109 = x_185; +goto block_183; +} +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +block_99: +{ +lean_object* x_57; +x_57 = lean_ctor_get(x_55, 0); +lean_inc(x_57); +if (lean_obj_tag(x_57) == 0) +{ +lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_58 = lean_ctor_get(x_57, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = !lean_is_exclusive(x_55); +if (x_60 == 0) +{ +lean_object* x_61; uint8_t x_62; +x_61 = lean_ctor_get(x_55, 0); +lean_dec(x_61); +x_62 = !lean_is_exclusive(x_57); +if (x_62 == 0) +{ +lean_object* x_63; uint8_t x_64; +x_63 = lean_ctor_get(x_57, 0); +lean_dec(x_63); +x_64 = !lean_is_exclusive(x_59); +if (x_64 == 0) +{ +lean_object* x_65; +x_65 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_65, 0, x_59); +lean_ctor_set(x_57, 0, x_65); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_66 = lean_ctor_get(x_59, 0); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_59); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +x_69 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_57, 0, x_69); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_70 = lean_ctor_get(x_57, 1); +lean_inc(x_70); +lean_dec(x_57); +x_71 = lean_ctor_get(x_59, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_59, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_73 = x_59; +} else { + lean_dec_ref(x_59); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +x_75 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_75, 0, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_70); +lean_ctor_set(x_55, 0, x_76); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_77 = lean_ctor_get(x_55, 1); +lean_inc(x_77); +lean_dec(x_55); +x_78 = lean_ctor_get(x_57, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_79 = x_57; +} else { + lean_dec_ref(x_57); + x_79 = lean_box(0); +} +x_80 = lean_ctor_get(x_59, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_59, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_82 = x_59; +} else { + lean_dec_ref(x_59); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_82)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_82; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_81); +x_84 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_84, 0, x_83); +if (lean_is_scalar(x_79)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_79; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_78); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_12 = x_86; +x_13 = x_56; +goto block_54; +} +} +else +{ +uint8_t x_87; +x_87 = !lean_is_exclusive(x_55); +if (x_87 == 0) +{ +lean_object* x_88; uint8_t x_89; +x_88 = lean_ctor_get(x_55, 0); +lean_dec(x_88); +x_89 = !lean_is_exclusive(x_57); +if (x_89 == 0) +{ +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_57, 0); +x_91 = lean_ctor_get(x_57, 1); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_57); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set(x_92, 1, x_91); +lean_ctor_set(x_55, 0, x_92); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_93 = lean_ctor_get(x_55, 1); +lean_inc(x_93); +lean_dec(x_55); +x_94 = lean_ctor_get(x_57, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_57, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_96 = x_57; +} else { + lean_dec_ref(x_57); + x_96 = lean_box(0); +} +if (lean_is_scalar(x_96)) { + x_97 = lean_alloc_ctor(1, 2, 0); +} else { + x_97 = x_96; +} +lean_ctor_set(x_97, 0, x_94); +lean_ctor_set(x_97, 1, x_95); +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_93); +x_12 = x_98; +x_13 = x_56; +goto block_54; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recComputeTransImports(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Lake_Module_importsFacetConfig___closed__2; +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +x_10 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; size_t x_31; size_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_58; lean_object* x_59; +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_14 = x_10; +} else { + lean_dec_ref(x_10); + x_14 = lean_box(0); +} +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = lean_ctor_get(x_12, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_12, 1); +lean_inc(x_17); +lean_dec(x_12); +x_18 = lean_ctor_get(x_1, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_19, 2); +lean_inc(x_21); +lean_dec(x_19); +x_22 = lean_ctor_get(x_21, 7); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_System_FilePath_join(x_20, x_22); +x_24 = lean_ctor_get(x_18, 1); +lean_inc(x_24); +lean_dec(x_18); +x_25 = lean_ctor_get(x_24, 2); +lean_inc(x_25); +lean_dec(x_24); +x_26 = l_System_FilePath_join(x_23, x_25); +x_27 = lean_ctor_get(x_1, 1); +lean_inc(x_27); +lean_dec(x_1); +x_28 = l_Lake_Module_recParseImports___closed__1; +x_29 = l_Lean_modToFilePath(x_26, x_27, x_28); +lean_dec(x_26); +x_30 = lean_array_get_size(x_16); +x_31 = lean_usize_of_nat(x_30); +lean_dec(x_30); +x_32 = 0; +x_33 = lean_array_get_size(x_17); +x_58 = l_Lake_collectImportsAux___closed__1; +x_59 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1(x_29, x_16, x_31, x_32, x_58, x_2, x_3, x_4, x_17, x_15, x_13); +lean_dec(x_16); +lean_dec(x_29); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; lean_object* x_61; +x_60 = lean_ctor_get(x_59, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +if (lean_obj_tag(x_61) == 0) +{ +lean_object* x_62; lean_object* x_63; uint8_t x_64; +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +x_64 = lean_unbox(x_63); +lean_dec(x_63); +if (x_64 == 0) +{ +lean_object* x_65; uint8_t x_66; +x_65 = lean_ctor_get(x_59, 1); +lean_inc(x_65); +lean_dec(x_59); +x_66 = !lean_is_exclusive(x_60); +if (x_66 == 0) +{ +lean_object* x_67; uint8_t x_68; +x_67 = lean_ctor_get(x_60, 0); +lean_dec(x_67); +x_68 = !lean_is_exclusive(x_61); +if (x_68 == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_61, 0); +lean_dec(x_69); +x_70 = lean_ctor_get(x_62, 1); +lean_inc(x_70); +lean_dec(x_62); +x_71 = lean_ctor_get(x_70, 1); +lean_inc(x_71); +lean_dec(x_70); +lean_ctor_set(x_61, 0, x_71); +x_34 = x_60; +x_35 = x_65; +goto block_57; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_72 = lean_ctor_get(x_61, 1); +lean_inc(x_72); +lean_dec(x_61); +x_73 = lean_ctor_get(x_62, 1); +lean_inc(x_73); +lean_dec(x_62); +x_74 = lean_ctor_get(x_73, 1); +lean_inc(x_74); +lean_dec(x_73); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_72); +lean_ctor_set(x_60, 0, x_75); +x_34 = x_60; +x_35 = x_65; +goto block_57; +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_76 = lean_ctor_get(x_60, 1); +lean_inc(x_76); +lean_dec(x_60); +x_77 = lean_ctor_get(x_61, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_61)) { + lean_ctor_release(x_61, 0); + lean_ctor_release(x_61, 1); + x_78 = x_61; +} else { + lean_dec_ref(x_61); + x_78 = lean_box(0); +} +x_79 = lean_ctor_get(x_62, 1); +lean_inc(x_79); +lean_dec(x_62); +x_80 = lean_ctor_get(x_79, 1); +lean_inc(x_80); +lean_dec(x_79); +if (lean_is_scalar(x_78)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_78; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_77); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_76); +x_34 = x_82; +x_35 = x_65; +goto block_57; +} +} +else +{ +lean_object* x_83; uint8_t x_84; +lean_dec(x_62); +x_83 = lean_ctor_get(x_59, 1); +lean_inc(x_83); +lean_dec(x_59); +x_84 = !lean_is_exclusive(x_60); +if (x_84 == 0) +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_60, 0); +lean_dec(x_85); +x_86 = !lean_is_exclusive(x_61); +if (x_86 == 0) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_61, 1); +x_88 = lean_ctor_get(x_61, 0); +lean_dec(x_88); +x_89 = lean_array_get_size(x_87); +lean_ctor_set_tag(x_61, 1); +lean_ctor_set(x_61, 0, x_89); +x_34 = x_60; +x_35 = x_83; +goto block_57; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_61, 1); +lean_inc(x_90); +lean_dec(x_61); +x_91 = lean_array_get_size(x_90); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_90); +lean_ctor_set(x_60, 0, x_92); +x_34 = x_60; +x_35 = x_83; +goto block_57; +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_93 = lean_ctor_get(x_60, 1); +lean_inc(x_93); +lean_dec(x_60); +x_94 = lean_ctor_get(x_61, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_61)) { + lean_ctor_release(x_61, 0); + lean_ctor_release(x_61, 1); + x_95 = x_61; +} else { + lean_dec_ref(x_61); + x_95 = lean_box(0); +} +x_96 = lean_array_get_size(x_94); +if (lean_is_scalar(x_95)) { + x_97 = lean_alloc_ctor(1, 2, 0); +} else { + x_97 = x_95; + lean_ctor_set_tag(x_97, 1); +} +lean_ctor_set(x_97, 0, x_96); +lean_ctor_set(x_97, 1, x_94); +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_93); +x_34 = x_98; +x_35 = x_83; +goto block_57; +} +} +} +else +{ +lean_object* x_99; uint8_t x_100; +x_99 = lean_ctor_get(x_59, 1); +lean_inc(x_99); +lean_dec(x_59); +x_100 = !lean_is_exclusive(x_60); +if (x_100 == 0) +{ +lean_object* x_101; uint8_t x_102; +x_101 = lean_ctor_get(x_60, 0); +lean_dec(x_101); +x_102 = !lean_is_exclusive(x_61); +if (x_102 == 0) +{ +x_34 = x_60; +x_35 = x_99; +goto block_57; +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; +x_103 = lean_ctor_get(x_61, 0); +x_104 = lean_ctor_get(x_61, 1); +lean_inc(x_104); +lean_inc(x_103); +lean_dec(x_61); +x_105 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_105, 0, x_103); +lean_ctor_set(x_105, 1, x_104); +lean_ctor_set(x_60, 0, x_105); +x_34 = x_60; +x_35 = x_99; +goto block_57; +} +} +else +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_106 = lean_ctor_get(x_60, 1); +lean_inc(x_106); +lean_dec(x_60); +x_107 = lean_ctor_get(x_61, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_61, 1); +lean_inc(x_108); +if (lean_is_exclusive(x_61)) { + lean_ctor_release(x_61, 0); + lean_ctor_release(x_61, 1); + x_109 = x_61; +} else { + lean_dec_ref(x_61); + x_109 = lean_box(0); +} +if (lean_is_scalar(x_109)) { + x_110 = lean_alloc_ctor(1, 2, 0); +} else { + x_110 = x_109; +} +lean_ctor_set(x_110, 0, x_107); +lean_ctor_set(x_110, 1, x_108); +x_111 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_111, 0, x_110); +lean_ctor_set(x_111, 1, x_106); +x_34 = x_111; +x_35 = x_99; +goto block_57; +} +} +} +else +{ +uint8_t x_112; +lean_dec(x_33); +lean_dec(x_14); +x_112 = !lean_is_exclusive(x_59); +if (x_112 == 0) +{ +return x_59; +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_113 = lean_ctor_get(x_59, 0); +x_114 = lean_ctor_get(x_59, 1); +lean_inc(x_114); +lean_inc(x_113); +lean_dec(x_59); +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; +} +} +block_57: +{ +lean_object* x_36; +x_36 = lean_ctor_get(x_34, 0); +lean_inc(x_36); +if (lean_obj_tag(x_36) == 0) +{ +uint8_t x_37; +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +x_38 = lean_ctor_get(x_34, 0); +lean_dec(x_38); +if (lean_is_scalar(x_14)) { + x_39 = lean_alloc_ctor(0, 2, 0); +} else { + x_39 = x_14; +} +lean_ctor_set(x_39, 0, x_34); +lean_ctor_set(x_39, 1, x_35); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_34, 1); +lean_inc(x_40); +lean_dec(x_34); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_36); +lean_ctor_set(x_41, 1, x_40); +if (lean_is_scalar(x_14)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_14; +} +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_35); +return x_42; +} +} +else +{ +uint8_t x_43; +x_43 = !lean_is_exclusive(x_34); +if (x_43 == 0) +{ +lean_object* x_44; uint8_t x_45; +x_44 = lean_ctor_get(x_34, 0); +lean_dec(x_44); +x_45 = !lean_is_exclusive(x_36); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; +x_46 = lean_ctor_get(x_36, 0); +lean_dec(x_46); +lean_ctor_set(x_36, 0, x_33); +if (lean_is_scalar(x_14)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_14; +} +lean_ctor_set(x_47, 0, x_34); +lean_ctor_set(x_47, 1, x_35); +return x_47; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_36, 1); +lean_inc(x_48); +lean_dec(x_36); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_33); +lean_ctor_set(x_49, 1, x_48); +lean_ctor_set(x_34, 0, x_49); +if (lean_is_scalar(x_14)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_14; +} +lean_ctor_set(x_50, 0, x_34); +lean_ctor_set(x_50, 1, x_35); +return x_50; +} +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_51 = lean_ctor_get(x_34, 1); +lean_inc(x_51); +lean_dec(x_34); +x_52 = lean_ctor_get(x_36, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_53 = x_36; +} else { + lean_dec_ref(x_36); + x_53 = lean_box(0); +} +if (lean_is_scalar(x_53)) { + x_54 = lean_alloc_ctor(1, 2, 0); +} else { + x_54 = x_53; +} +lean_ctor_set(x_54, 0, x_33); +lean_ctor_set(x_54, 1, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_51); +if (lean_is_scalar(x_14)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_14; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_35); +return x_56; +} +} +} +} +else +{ +uint8_t x_116; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_116 = !lean_is_exclusive(x_10); +if (x_116 == 0) +{ +lean_object* x_117; uint8_t x_118; +x_117 = lean_ctor_get(x_10, 0); +lean_dec(x_117); +x_118 = !lean_is_exclusive(x_11); +if (x_118 == 0) +{ +lean_object* x_119; uint8_t x_120; +x_119 = lean_ctor_get(x_11, 0); +lean_dec(x_119); +x_120 = !lean_is_exclusive(x_12); +if (x_120 == 0) +{ +return x_10; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_121 = lean_ctor_get(x_12, 0); +x_122 = lean_ctor_get(x_12, 1); +lean_inc(x_122); +lean_inc(x_121); +lean_dec(x_12); +x_123 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_123, 0, x_121); +lean_ctor_set(x_123, 1, x_122); +lean_ctor_set(x_11, 0, x_123); +return x_10; +} +} +else +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_124 = lean_ctor_get(x_11, 1); +lean_inc(x_124); +lean_dec(x_11); +x_125 = lean_ctor_get(x_12, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_12, 1); +lean_inc(x_126); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_127 = x_12; +} else { + lean_dec_ref(x_12); + x_127 = lean_box(0); +} +if (lean_is_scalar(x_127)) { + x_128 = lean_alloc_ctor(1, 2, 0); +} else { + x_128 = x_127; +} +lean_ctor_set(x_128, 0, x_125); +lean_ctor_set(x_128, 1, x_126); +x_129 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set(x_129, 1, x_124); +lean_ctor_set(x_10, 0, x_129); +return x_10; +} +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_130 = lean_ctor_get(x_10, 1); +lean_inc(x_130); +lean_dec(x_10); +x_131 = lean_ctor_get(x_11, 1); +lean_inc(x_131); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_132 = x_11; +} else { + lean_dec_ref(x_11); + x_132 = lean_box(0); +} +x_133 = lean_ctor_get(x_12, 0); +lean_inc(x_133); +x_134 = lean_ctor_get(x_12, 1); +lean_inc(x_134); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_135 = x_12; +} else { + lean_dec_ref(x_12); + x_135 = lean_box(0); +} +if (lean_is_scalar(x_135)) { + x_136 = lean_alloc_ctor(1, 2, 0); +} else { + x_136 = x_135; +} +lean_ctor_set(x_136, 0, x_133); +lean_ctor_set(x_136, 1, x_134); +if (lean_is_scalar(x_132)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_132; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_131); +x_138 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_138, 0, x_137); +lean_ctor_set(x_138, 1, x_130); +return x_138; +} +} +} +else +{ +uint8_t x_139; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_139 = !lean_is_exclusive(x_10); +if (x_139 == 0) +{ +return x_10; +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; +x_140 = lean_ctor_get(x_10, 0); +x_141 = lean_ctor_get(x_10, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_10); +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; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +lean_dec(x_1); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_transImportsFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Module_recComputeTransImports(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +return x_8; +} +} +static lean_object* _init_l_Lake_Module_transImportsFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_transImportsFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_transImportsFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_transImportsFacetConfig___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_transImportsFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_transImportsFacetConfig___closed__2; +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("precompileImports", 17); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_recParseImports___closed__1; +x_2 = l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_55; lean_object* x_56; uint8_t x_100; +x_100 = lean_usize_dec_lt(x_4, x_3); +if (x_100 == 0) +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_5); +lean_ctor_set(x_101, 1, x_9); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_10); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_11); +return x_103; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_184; lean_object* x_185; lean_object* x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; +x_104 = lean_array_uget(x_2, x_4); +x_105 = lean_ctor_get(x_5, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_5, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_107 = x_5; +} else { + lean_dec_ref(x_5); + x_107 = lean_box(0); +} +x_246 = lean_ctor_get(x_104, 0); +lean_inc(x_246); +x_247 = lean_ctor_get(x_246, 0); +lean_inc(x_247); +x_248 = lean_ctor_get(x_247, 2); +lean_inc(x_248); +lean_dec(x_247); +x_249 = lean_ctor_get_uint8(x_248, sizeof(void*)*21); +lean_dec(x_248); +if (x_249 == 0) +{ +lean_object* x_250; uint8_t x_251; +x_250 = lean_ctor_get(x_246, 1); +lean_inc(x_250); +lean_dec(x_246); +x_251 = lean_ctor_get_uint8(x_250, sizeof(void*)*9); +lean_dec(x_250); +if (x_251 == 0) +{ +lean_object* x_252; lean_object* x_253; lean_object* x_254; +x_252 = l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2; +lean_inc(x_104); +x_253 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_253, 0, x_104); +lean_ctor_set(x_253, 1, x_252); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_254 = lean_apply_6(x_6, x_253, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_254) == 0) +{ +lean_object* x_255; lean_object* x_256; +x_255 = lean_ctor_get(x_254, 0); +lean_inc(x_255); +x_256 = lean_ctor_get(x_255, 0); +lean_inc(x_256); +if (lean_obj_tag(x_256) == 0) +{ +lean_object* x_257; uint8_t x_258; +x_257 = lean_ctor_get(x_254, 1); +lean_inc(x_257); +lean_dec(x_254); +x_258 = !lean_is_exclusive(x_255); +if (x_258 == 0) +{ +lean_object* x_259; lean_object* x_260; uint8_t x_261; +x_259 = lean_ctor_get(x_255, 1); +x_260 = lean_ctor_get(x_255, 0); +lean_dec(x_260); +x_261 = !lean_is_exclusive(x_256); +if (x_261 == 0) +{ +lean_object* x_262; uint8_t x_263; lean_object* x_264; lean_object* x_265; +x_262 = lean_ctor_get(x_256, 0); +x_263 = 0; +x_264 = lean_box(x_263); +lean_ctor_set(x_255, 1, x_262); +lean_ctor_set(x_255, 0, x_264); +lean_ctor_set(x_256, 0, x_255); +x_265 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_265, 0, x_256); +lean_ctor_set(x_265, 1, x_259); +x_184 = x_265; +x_185 = x_257; +goto block_245; +} +else +{ +lean_object* x_266; lean_object* x_267; uint8_t x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; +x_266 = lean_ctor_get(x_256, 0); +x_267 = lean_ctor_get(x_256, 1); +lean_inc(x_267); +lean_inc(x_266); +lean_dec(x_256); +x_268 = 0; +x_269 = lean_box(x_268); +lean_ctor_set(x_255, 1, x_266); +lean_ctor_set(x_255, 0, x_269); +x_270 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_270, 0, x_255); +lean_ctor_set(x_270, 1, x_267); +x_271 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_271, 0, x_270); +lean_ctor_set(x_271, 1, x_259); +x_184 = x_271; +x_185 = x_257; +goto block_245; +} +} +else +{ +lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; uint8_t x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; +x_272 = lean_ctor_get(x_255, 1); +lean_inc(x_272); +lean_dec(x_255); +x_273 = lean_ctor_get(x_256, 0); +lean_inc(x_273); +x_274 = lean_ctor_get(x_256, 1); +lean_inc(x_274); +if (lean_is_exclusive(x_256)) { + lean_ctor_release(x_256, 0); + lean_ctor_release(x_256, 1); + x_275 = x_256; +} else { + lean_dec_ref(x_256); + x_275 = lean_box(0); +} +x_276 = 0; +x_277 = lean_box(x_276); +x_278 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_278, 0, x_277); +lean_ctor_set(x_278, 1, x_273); +if (lean_is_scalar(x_275)) { + x_279 = lean_alloc_ctor(0, 2, 0); +} else { + x_279 = x_275; +} +lean_ctor_set(x_279, 0, x_278); +lean_ctor_set(x_279, 1, x_274); +x_280 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_280, 0, x_279); +lean_ctor_set(x_280, 1, x_272); +x_184 = x_280; +x_185 = x_257; +goto block_245; +} +} +else +{ +lean_object* x_281; uint8_t x_282; +x_281 = lean_ctor_get(x_254, 1); +lean_inc(x_281); +lean_dec(x_254); +x_282 = !lean_is_exclusive(x_255); +if (x_282 == 0) +{ +lean_object* x_283; uint8_t x_284; +x_283 = lean_ctor_get(x_255, 0); +lean_dec(x_283); +x_284 = !lean_is_exclusive(x_256); +if (x_284 == 0) +{ +x_184 = x_255; +x_185 = x_281; +goto block_245; +} +else +{ +lean_object* x_285; lean_object* x_286; lean_object* x_287; +x_285 = lean_ctor_get(x_256, 0); +x_286 = lean_ctor_get(x_256, 1); +lean_inc(x_286); +lean_inc(x_285); +lean_dec(x_256); +x_287 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_287, 0, x_285); +lean_ctor_set(x_287, 1, x_286); +lean_ctor_set(x_255, 0, x_287); +x_184 = x_255; +x_185 = x_281; +goto block_245; +} +} +else +{ +lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; +x_288 = lean_ctor_get(x_255, 1); +lean_inc(x_288); +lean_dec(x_255); +x_289 = lean_ctor_get(x_256, 0); +lean_inc(x_289); +x_290 = lean_ctor_get(x_256, 1); +lean_inc(x_290); +if (lean_is_exclusive(x_256)) { + lean_ctor_release(x_256, 0); + lean_ctor_release(x_256, 1); + x_291 = x_256; +} else { + lean_dec_ref(x_256); + x_291 = lean_box(0); +} +if (lean_is_scalar(x_291)) { + x_292 = lean_alloc_ctor(1, 2, 0); +} else { + x_292 = x_291; +} +lean_ctor_set(x_292, 0, x_289); +lean_ctor_set(x_292, 1, x_290); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_288); +x_184 = x_293; +x_185 = x_281; +goto block_245; +} +} +} +else +{ +uint8_t x_294; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_294 = !lean_is_exclusive(x_254); +if (x_294 == 0) +{ +return x_254; +} +else +{ +lean_object* x_295; lean_object* x_296; lean_object* x_297; +x_295 = lean_ctor_get(x_254, 0); +x_296 = lean_ctor_get(x_254, 1); +lean_inc(x_296); +lean_inc(x_295); +lean_dec(x_254); +x_297 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_297, 0, x_295); +lean_ctor_set(x_297, 1, x_296); +return x_297; +} +} +} +else +{ +lean_object* x_298; lean_object* x_299; lean_object* x_300; +x_298 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +lean_inc(x_104); +x_299 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_299, 0, x_104); +lean_ctor_set(x_299, 1, x_298); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_300 = lean_apply_6(x_6, x_299, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_300) == 0) +{ +lean_object* x_301; lean_object* x_302; +x_301 = lean_ctor_get(x_300, 0); +lean_inc(x_301); +x_302 = lean_ctor_get(x_301, 0); +lean_inc(x_302); +if (lean_obj_tag(x_302) == 0) +{ +lean_object* x_303; uint8_t x_304; +x_303 = lean_ctor_get(x_300, 1); +lean_inc(x_303); +lean_dec(x_300); +x_304 = !lean_is_exclusive(x_301); +if (x_304 == 0) +{ +lean_object* x_305; lean_object* x_306; uint8_t x_307; +x_305 = lean_ctor_get(x_301, 1); +x_306 = lean_ctor_get(x_301, 0); +lean_dec(x_306); +x_307 = !lean_is_exclusive(x_302); +if (x_307 == 0) +{ +lean_object* x_308; uint8_t x_309; lean_object* x_310; lean_object* x_311; +x_308 = lean_ctor_get(x_302, 0); +x_309 = 1; +x_310 = lean_box(x_309); +lean_ctor_set(x_301, 1, x_308); +lean_ctor_set(x_301, 0, x_310); +lean_ctor_set(x_302, 0, x_301); +x_311 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_311, 0, x_302); +lean_ctor_set(x_311, 1, x_305); +x_184 = x_311; +x_185 = x_303; +goto block_245; +} +else +{ +lean_object* x_312; lean_object* x_313; uint8_t x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; +x_312 = lean_ctor_get(x_302, 0); +x_313 = lean_ctor_get(x_302, 1); +lean_inc(x_313); +lean_inc(x_312); +lean_dec(x_302); +x_314 = 1; +x_315 = lean_box(x_314); +lean_ctor_set(x_301, 1, x_312); +lean_ctor_set(x_301, 0, x_315); +x_316 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_316, 0, x_301); +lean_ctor_set(x_316, 1, x_313); +x_317 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_317, 0, x_316); +lean_ctor_set(x_317, 1, x_305); +x_184 = x_317; +x_185 = x_303; +goto block_245; +} +} +else +{ +lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; uint8_t x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; +x_318 = lean_ctor_get(x_301, 1); +lean_inc(x_318); +lean_dec(x_301); +x_319 = lean_ctor_get(x_302, 0); +lean_inc(x_319); +x_320 = lean_ctor_get(x_302, 1); +lean_inc(x_320); +if (lean_is_exclusive(x_302)) { + lean_ctor_release(x_302, 0); + lean_ctor_release(x_302, 1); + x_321 = x_302; +} else { + lean_dec_ref(x_302); + x_321 = lean_box(0); +} +x_322 = 1; +x_323 = lean_box(x_322); +x_324 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_324, 0, x_323); +lean_ctor_set(x_324, 1, x_319); +if (lean_is_scalar(x_321)) { + x_325 = lean_alloc_ctor(0, 2, 0); +} else { + x_325 = x_321; +} +lean_ctor_set(x_325, 0, x_324); +lean_ctor_set(x_325, 1, x_320); +x_326 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_326, 0, x_325); +lean_ctor_set(x_326, 1, x_318); +x_184 = x_326; +x_185 = x_303; +goto block_245; +} +} +else +{ +lean_object* x_327; uint8_t x_328; +x_327 = lean_ctor_get(x_300, 1); +lean_inc(x_327); +lean_dec(x_300); +x_328 = !lean_is_exclusive(x_301); +if (x_328 == 0) +{ +lean_object* x_329; uint8_t x_330; +x_329 = lean_ctor_get(x_301, 0); +lean_dec(x_329); +x_330 = !lean_is_exclusive(x_302); +if (x_330 == 0) +{ +x_184 = x_301; +x_185 = x_327; +goto block_245; +} +else +{ +lean_object* x_331; lean_object* x_332; lean_object* x_333; +x_331 = lean_ctor_get(x_302, 0); +x_332 = lean_ctor_get(x_302, 1); +lean_inc(x_332); +lean_inc(x_331); +lean_dec(x_302); +x_333 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_333, 0, x_331); +lean_ctor_set(x_333, 1, x_332); +lean_ctor_set(x_301, 0, x_333); +x_184 = x_301; +x_185 = x_327; +goto block_245; +} +} +else +{ +lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; +x_334 = lean_ctor_get(x_301, 1); +lean_inc(x_334); +lean_dec(x_301); +x_335 = lean_ctor_get(x_302, 0); +lean_inc(x_335); +x_336 = lean_ctor_get(x_302, 1); +lean_inc(x_336); +if (lean_is_exclusive(x_302)) { + lean_ctor_release(x_302, 0); + lean_ctor_release(x_302, 1); + x_337 = x_302; +} else { + lean_dec_ref(x_302); + x_337 = lean_box(0); +} +if (lean_is_scalar(x_337)) { + x_338 = lean_alloc_ctor(1, 2, 0); +} else { + x_338 = x_337; +} +lean_ctor_set(x_338, 0, x_335); +lean_ctor_set(x_338, 1, x_336); +x_339 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_339, 0, x_338); +lean_ctor_set(x_339, 1, x_334); +x_184 = x_339; +x_185 = x_327; +goto block_245; +} +} +} +else +{ +uint8_t x_340; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_340 = !lean_is_exclusive(x_300); +if (x_340 == 0) +{ +return x_300; +} +else +{ +lean_object* x_341; lean_object* x_342; lean_object* x_343; +x_341 = lean_ctor_get(x_300, 0); +x_342 = lean_ctor_get(x_300, 1); +lean_inc(x_342); +lean_inc(x_341); +lean_dec(x_300); +x_343 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_343, 0, x_341); +lean_ctor_set(x_343, 1, x_342); +return x_343; +} +} +} +} +else +{ +lean_object* x_344; lean_object* x_345; lean_object* x_346; +lean_dec(x_246); +x_344 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +lean_inc(x_104); +x_345 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_345, 0, x_104); +lean_ctor_set(x_345, 1, x_344); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_346 = lean_apply_6(x_6, x_345, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_346) == 0) +{ +lean_object* x_347; lean_object* x_348; +x_347 = lean_ctor_get(x_346, 0); +lean_inc(x_347); +x_348 = lean_ctor_get(x_347, 0); +lean_inc(x_348); +if (lean_obj_tag(x_348) == 0) +{ +lean_object* x_349; uint8_t x_350; +x_349 = lean_ctor_get(x_346, 1); +lean_inc(x_349); +lean_dec(x_346); +x_350 = !lean_is_exclusive(x_347); +if (x_350 == 0) +{ +lean_object* x_351; lean_object* x_352; uint8_t x_353; +x_351 = lean_ctor_get(x_347, 1); +x_352 = lean_ctor_get(x_347, 0); +lean_dec(x_352); +x_353 = !lean_is_exclusive(x_348); +if (x_353 == 0) +{ +lean_object* x_354; uint8_t x_355; lean_object* x_356; lean_object* x_357; +x_354 = lean_ctor_get(x_348, 0); +x_355 = 1; +x_356 = lean_box(x_355); +lean_ctor_set(x_347, 1, x_354); +lean_ctor_set(x_347, 0, x_356); +lean_ctor_set(x_348, 0, x_347); +x_357 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_357, 0, x_348); +lean_ctor_set(x_357, 1, x_351); +x_184 = x_357; +x_185 = x_349; +goto block_245; +} +else +{ +lean_object* x_358; lean_object* x_359; uint8_t x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; +x_358 = lean_ctor_get(x_348, 0); +x_359 = lean_ctor_get(x_348, 1); +lean_inc(x_359); +lean_inc(x_358); +lean_dec(x_348); +x_360 = 1; +x_361 = lean_box(x_360); +lean_ctor_set(x_347, 1, x_358); +lean_ctor_set(x_347, 0, x_361); +x_362 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_362, 0, x_347); +lean_ctor_set(x_362, 1, x_359); +x_363 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_363, 0, x_362); +lean_ctor_set(x_363, 1, x_351); +x_184 = x_363; +x_185 = x_349; +goto block_245; +} +} +else +{ +lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; uint8_t x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; +x_364 = lean_ctor_get(x_347, 1); +lean_inc(x_364); +lean_dec(x_347); +x_365 = lean_ctor_get(x_348, 0); +lean_inc(x_365); +x_366 = lean_ctor_get(x_348, 1); +lean_inc(x_366); +if (lean_is_exclusive(x_348)) { + lean_ctor_release(x_348, 0); + lean_ctor_release(x_348, 1); + x_367 = x_348; +} else { + lean_dec_ref(x_348); + x_367 = lean_box(0); +} +x_368 = 1; +x_369 = lean_box(x_368); +x_370 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_370, 0, x_369); +lean_ctor_set(x_370, 1, x_365); +if (lean_is_scalar(x_367)) { + x_371 = lean_alloc_ctor(0, 2, 0); +} else { + x_371 = x_367; +} +lean_ctor_set(x_371, 0, x_370); +lean_ctor_set(x_371, 1, x_366); +x_372 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_372, 0, x_371); +lean_ctor_set(x_372, 1, x_364); +x_184 = x_372; +x_185 = x_349; +goto block_245; +} +} +else +{ +lean_object* x_373; uint8_t x_374; +x_373 = lean_ctor_get(x_346, 1); +lean_inc(x_373); +lean_dec(x_346); +x_374 = !lean_is_exclusive(x_347); +if (x_374 == 0) +{ +lean_object* x_375; uint8_t x_376; +x_375 = lean_ctor_get(x_347, 0); +lean_dec(x_375); +x_376 = !lean_is_exclusive(x_348); +if (x_376 == 0) +{ +x_184 = x_347; +x_185 = x_373; +goto block_245; +} +else +{ +lean_object* x_377; lean_object* x_378; lean_object* x_379; +x_377 = lean_ctor_get(x_348, 0); +x_378 = lean_ctor_get(x_348, 1); +lean_inc(x_378); +lean_inc(x_377); +lean_dec(x_348); +x_379 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_379, 0, x_377); +lean_ctor_set(x_379, 1, x_378); +lean_ctor_set(x_347, 0, x_379); +x_184 = x_347; +x_185 = x_373; +goto block_245; +} +} +else +{ +lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; +x_380 = lean_ctor_get(x_347, 1); +lean_inc(x_380); +lean_dec(x_347); +x_381 = lean_ctor_get(x_348, 0); +lean_inc(x_381); +x_382 = lean_ctor_get(x_348, 1); +lean_inc(x_382); +if (lean_is_exclusive(x_348)) { + lean_ctor_release(x_348, 0); + lean_ctor_release(x_348, 1); + x_383 = x_348; +} else { + lean_dec_ref(x_348); + x_383 = lean_box(0); +} +if (lean_is_scalar(x_383)) { + x_384 = lean_alloc_ctor(1, 2, 0); +} else { + x_384 = x_383; +} +lean_ctor_set(x_384, 0, x_381); +lean_ctor_set(x_384, 1, x_382); +x_385 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_385, 0, x_384); +lean_ctor_set(x_385, 1, x_380); +x_184 = x_385; +x_185 = x_373; +goto block_245; +} +} +} +else +{ +uint8_t x_386; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_386 = !lean_is_exclusive(x_346); +if (x_386 == 0) +{ +return x_346; +} +else +{ +lean_object* x_387; lean_object* x_388; lean_object* x_389; +x_387 = lean_ctor_get(x_346, 0); +x_388 = lean_ctor_get(x_346, 1); +lean_inc(x_388); +lean_inc(x_387); +lean_dec(x_346); +x_389 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_389, 0, x_387); +lean_ctor_set(x_389, 1, x_388); +return x_389; +} +} +} +block_183: +{ +lean_object* x_110; +x_110 = lean_ctor_get(x_108, 0); +lean_inc(x_110); +if (lean_obj_tag(x_110) == 0) +{ +uint8_t x_111; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_104); +x_111 = !lean_is_exclusive(x_108); +if (x_111 == 0) +{ +lean_object* x_112; +x_112 = lean_ctor_get(x_108, 0); +lean_dec(x_112); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_113; lean_object* x_114; +x_113 = lean_ctor_get(x_108, 1); +lean_inc(x_113); +lean_dec(x_108); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_110); +lean_ctor_set(x_114, 1, x_113); +x_55 = x_114; +x_56 = x_109; +goto block_99; +} +} +else +{ +uint8_t x_115; +x_115 = !lean_is_exclusive(x_108); +if (x_115 == 0) +{ +lean_object* x_116; uint8_t x_117; +x_116 = lean_ctor_get(x_108, 0); +lean_dec(x_116); +x_117 = !lean_is_exclusive(x_110); +if (x_117 == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_118 = lean_ctor_get(x_110, 0); +x_119 = lean_ctor_get(x_110, 1); +x_120 = l_Array_shrink___rarg(x_119, x_118); +lean_dec(x_118); +x_121 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_122 = lean_string_append(x_121, x_1); +x_123 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_124 = lean_string_append(x_122, x_123); +x_125 = lean_ctor_get(x_104, 1); +lean_inc(x_125); +lean_dec(x_104); +x_126 = 1; +x_127 = l_Lean_Name_toString(x_125, x_126); +x_128 = lean_string_append(x_124, x_127); +lean_dec(x_127); +x_129 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_130 = lean_string_append(x_128, x_129); +x_131 = 3; +x_132 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set_uint8(x_132, sizeof(void*)*1, x_131); +x_133 = lean_array_push(x_120, x_132); +x_134 = lean_box(x_126); +if (lean_is_scalar(x_107)) { + x_135 = lean_alloc_ctor(0, 2, 0); +} else { + x_135 = x_107; +} +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_106); +x_136 = lean_box(0); +x_137 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_135); +lean_ctor_set_tag(x_110, 0); +lean_ctor_set(x_110, 1, x_133); +lean_ctor_set(x_110, 0, x_137); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +x_138 = lean_ctor_get(x_110, 0); +x_139 = lean_ctor_get(x_110, 1); +lean_inc(x_139); +lean_inc(x_138); +lean_dec(x_110); +x_140 = l_Array_shrink___rarg(x_139, x_138); +lean_dec(x_138); +x_141 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_142 = lean_string_append(x_141, x_1); +x_143 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_144 = lean_string_append(x_142, x_143); +x_145 = lean_ctor_get(x_104, 1); +lean_inc(x_145); +lean_dec(x_104); +x_146 = 1; +x_147 = l_Lean_Name_toString(x_145, x_146); +x_148 = lean_string_append(x_144, x_147); +lean_dec(x_147); +x_149 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_150 = lean_string_append(x_148, x_149); +x_151 = 3; +x_152 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set_uint8(x_152, sizeof(void*)*1, x_151); +x_153 = lean_array_push(x_140, x_152); +x_154 = lean_box(x_146); +if (lean_is_scalar(x_107)) { + x_155 = lean_alloc_ctor(0, 2, 0); +} else { + x_155 = x_107; +} +lean_ctor_set(x_155, 0, x_154); +lean_ctor_set(x_155, 1, x_106); +x_156 = lean_box(0); +x_157 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_157, 0, x_156); +lean_ctor_set(x_157, 1, x_155); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_157); +lean_ctor_set(x_158, 1, x_153); +lean_ctor_set(x_108, 0, x_158); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; uint8_t x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; +x_159 = lean_ctor_get(x_108, 1); +lean_inc(x_159); +lean_dec(x_108); +x_160 = lean_ctor_get(x_110, 0); +lean_inc(x_160); +x_161 = lean_ctor_get(x_110, 1); +lean_inc(x_161); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_162 = x_110; +} else { + lean_dec_ref(x_110); + x_162 = lean_box(0); +} +x_163 = l_Array_shrink___rarg(x_161, x_160); +lean_dec(x_160); +x_164 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_165 = lean_string_append(x_164, x_1); +x_166 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_167 = lean_string_append(x_165, x_166); +x_168 = lean_ctor_get(x_104, 1); +lean_inc(x_168); +lean_dec(x_104); +x_169 = 1; +x_170 = l_Lean_Name_toString(x_168, x_169); +x_171 = lean_string_append(x_167, x_170); +lean_dec(x_170); +x_172 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_173 = lean_string_append(x_171, x_172); +x_174 = 3; +x_175 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_175, 0, x_173); +lean_ctor_set_uint8(x_175, sizeof(void*)*1, x_174); +x_176 = lean_array_push(x_163, x_175); +x_177 = lean_box(x_169); +if (lean_is_scalar(x_107)) { + x_178 = lean_alloc_ctor(0, 2, 0); +} else { + x_178 = x_107; +} +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_106); +x_179 = lean_box(0); +x_180 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_178); +if (lean_is_scalar(x_162)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_162; + lean_ctor_set_tag(x_181, 0); +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_176); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_159); +x_55 = x_182; +x_56 = x_109; +goto block_99; +} +} +} +block_245: +{ +lean_object* x_186; +x_186 = lean_ctor_get(x_184, 0); +lean_inc(x_186); +if (lean_obj_tag(x_186) == 0) +{ +lean_object* x_187; lean_object* x_188; uint8_t x_189; +x_187 = lean_ctor_get(x_186, 0); +lean_inc(x_187); +x_188 = lean_ctor_get(x_184, 1); +lean_inc(x_188); +lean_dec(x_184); +x_189 = !lean_is_exclusive(x_186); +if (x_189 == 0) +{ +lean_object* x_190; uint8_t x_191; +x_190 = lean_ctor_get(x_186, 0); +lean_dec(x_190); +x_191 = !lean_is_exclusive(x_187); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; +x_192 = lean_ctor_get(x_187, 0); +x_193 = lean_ctor_get(x_187, 1); +lean_inc(x_106); +x_194 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_193); +lean_dec(x_193); +x_195 = lean_unbox(x_192); +lean_dec(x_192); +if (x_195 == 0) +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; +x_196 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_196, 0, x_105); +lean_ctor_set(x_196, 1, x_194); +x_197 = lean_box(0); +x_198 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_196); +lean_ctor_set(x_186, 0, x_198); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; +lean_inc(x_104); +x_199 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_194, x_104); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_105); +lean_ctor_set(x_200, 1, x_199); +x_201 = lean_box(0); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_201); +lean_ctor_set(x_202, 1, x_200); +lean_ctor_set(x_186, 0, x_202); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_203; lean_object* x_204; lean_object* x_205; uint8_t x_206; +x_203 = lean_ctor_get(x_187, 0); +x_204 = lean_ctor_get(x_187, 1); +lean_inc(x_204); +lean_inc(x_203); +lean_dec(x_187); +lean_inc(x_106); +x_205 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_204); +lean_dec(x_204); +x_206 = lean_unbox(x_203); +lean_dec(x_203); +if (x_206 == 0) +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +x_207 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_207, 0, x_105); +lean_ctor_set(x_207, 1, x_205); +x_208 = lean_box(0); +x_209 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_209, 0, x_208); +lean_ctor_set(x_209, 1, x_207); +lean_ctor_set(x_186, 0, x_209); +x_210 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_210, 0, x_186); +lean_ctor_set(x_210, 1, x_188); +x_108 = x_210; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +lean_inc(x_104); +x_211 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_205, x_104); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_105); +lean_ctor_set(x_212, 1, x_211); +x_213 = lean_box(0); +x_214 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_214, 0, x_213); +lean_ctor_set(x_214, 1, x_212); +lean_ctor_set(x_186, 0, x_214); +x_215 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_215, 0, x_186); +lean_ctor_set(x_215, 1, x_188); +x_108 = x_215; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; uint8_t x_221; +x_216 = lean_ctor_get(x_186, 1); +lean_inc(x_216); +lean_dec(x_186); +x_217 = lean_ctor_get(x_187, 0); +lean_inc(x_217); +x_218 = lean_ctor_get(x_187, 1); +lean_inc(x_218); +if (lean_is_exclusive(x_187)) { + lean_ctor_release(x_187, 0); + lean_ctor_release(x_187, 1); + x_219 = x_187; +} else { + lean_dec_ref(x_187); + x_219 = lean_box(0); +} +lean_inc(x_106); +x_220 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_218); +lean_dec(x_218); +x_221 = lean_unbox(x_217); +lean_dec(x_217); +if (x_221 == 0) +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_222 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_222, 0, x_105); +lean_ctor_set(x_222, 1, x_220); +x_223 = lean_box(0); +x_224 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_224, 0, x_223); +lean_ctor_set(x_224, 1, x_222); +x_225 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_225, 0, x_224); +lean_ctor_set(x_225, 1, x_216); +if (lean_is_scalar(x_219)) { + x_226 = lean_alloc_ctor(0, 2, 0); +} else { + x_226 = x_219; +} +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_188); +x_108 = x_226; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +lean_inc(x_104); +x_227 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_220, x_104); +x_228 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_228, 0, x_105); +lean_ctor_set(x_228, 1, x_227); +x_229 = lean_box(0); +x_230 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_230, 0, x_229); +lean_ctor_set(x_230, 1, x_228); +x_231 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_231, 0, x_230); +lean_ctor_set(x_231, 1, x_216); +if (lean_is_scalar(x_219)) { + x_232 = lean_alloc_ctor(0, 2, 0); +} else { + x_232 = x_219; +} +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_188); +x_108 = x_232; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +uint8_t x_233; +lean_dec(x_105); +x_233 = !lean_is_exclusive(x_184); +if (x_233 == 0) +{ +lean_object* x_234; uint8_t x_235; +x_234 = lean_ctor_get(x_184, 0); +lean_dec(x_234); +x_235 = !lean_is_exclusive(x_186); +if (x_235 == 0) +{ +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_236; lean_object* x_237; lean_object* x_238; +x_236 = lean_ctor_get(x_186, 0); +x_237 = lean_ctor_get(x_186, 1); +lean_inc(x_237); +lean_inc(x_236); +lean_dec(x_186); +x_238 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_238, 0, x_236); +lean_ctor_set(x_238, 1, x_237); +lean_ctor_set(x_184, 0, x_238); +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_239 = lean_ctor_get(x_184, 1); +lean_inc(x_239); +lean_dec(x_184); +x_240 = lean_ctor_get(x_186, 0); +lean_inc(x_240); +x_241 = lean_ctor_get(x_186, 1); +lean_inc(x_241); +if (lean_is_exclusive(x_186)) { + lean_ctor_release(x_186, 0); + lean_ctor_release(x_186, 1); + x_242 = x_186; +} else { + lean_dec_ref(x_186); + x_242 = lean_box(0); +} +if (lean_is_scalar(x_242)) { + x_243 = lean_alloc_ctor(1, 2, 0); +} else { + x_243 = x_242; +} +lean_ctor_set(x_243, 0, x_240); +lean_ctor_set(x_243, 1, x_241); +x_244 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_244, 0, x_243); +lean_ctor_set(x_244, 1, x_239); +x_108 = x_244; +x_109 = x_185; +goto block_183; +} +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +block_99: +{ +lean_object* x_57; +x_57 = lean_ctor_get(x_55, 0); +lean_inc(x_57); +if (lean_obj_tag(x_57) == 0) +{ +lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_58 = lean_ctor_get(x_57, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = !lean_is_exclusive(x_55); +if (x_60 == 0) +{ +lean_object* x_61; uint8_t x_62; +x_61 = lean_ctor_get(x_55, 0); +lean_dec(x_61); +x_62 = !lean_is_exclusive(x_57); +if (x_62 == 0) +{ +lean_object* x_63; uint8_t x_64; +x_63 = lean_ctor_get(x_57, 0); +lean_dec(x_63); +x_64 = !lean_is_exclusive(x_59); +if (x_64 == 0) +{ +lean_object* x_65; +x_65 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_65, 0, x_59); +lean_ctor_set(x_57, 0, x_65); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_66 = lean_ctor_get(x_59, 0); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_59); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +x_69 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_57, 0, x_69); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_70 = lean_ctor_get(x_57, 1); +lean_inc(x_70); +lean_dec(x_57); +x_71 = lean_ctor_get(x_59, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_59, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_73 = x_59; +} else { + lean_dec_ref(x_59); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +x_75 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_75, 0, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_70); +lean_ctor_set(x_55, 0, x_76); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_77 = lean_ctor_get(x_55, 1); +lean_inc(x_77); +lean_dec(x_55); +x_78 = lean_ctor_get(x_57, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_79 = x_57; +} else { + lean_dec_ref(x_57); + x_79 = lean_box(0); +} +x_80 = lean_ctor_get(x_59, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_59, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_82 = x_59; +} else { + lean_dec_ref(x_59); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_82)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_82; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_81); +x_84 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_84, 0, x_83); +if (lean_is_scalar(x_79)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_79; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_78); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_12 = x_86; +x_13 = x_56; +goto block_54; +} +} +else +{ +uint8_t x_87; +x_87 = !lean_is_exclusive(x_55); +if (x_87 == 0) +{ +lean_object* x_88; uint8_t x_89; +x_88 = lean_ctor_get(x_55, 0); +lean_dec(x_88); +x_89 = !lean_is_exclusive(x_57); +if (x_89 == 0) +{ +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_57, 0); +x_91 = lean_ctor_get(x_57, 1); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_57); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set(x_92, 1, x_91); +lean_ctor_set(x_55, 0, x_92); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_93 = lean_ctor_get(x_55, 1); +lean_inc(x_93); +lean_dec(x_55); +x_94 = lean_ctor_get(x_57, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_57, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_96 = x_57; +} else { + lean_dec_ref(x_57); + x_96 = lean_box(0); +} +if (lean_is_scalar(x_96)) { + x_97 = lean_alloc_ctor(1, 2, 0); +} else { + x_97 = x_96; +} +lean_ctor_set(x_97, 0, x_94); +lean_ctor_set(x_97, 1, x_95); +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_93); +x_12 = x_98; +x_13 = x_56; +goto block_54; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computePrecompileImportsAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; size_t x_10; size_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_37; lean_object* x_38; +x_9 = lean_array_get_size(x_2); +x_10 = lean_usize_of_nat(x_9); +lean_dec(x_9); +x_11 = 0; +x_12 = lean_array_get_size(x_6); +x_37 = l_Lake_collectImportsAux___closed__1; +x_38 = l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1(x_1, x_2, x_10, x_11, x_37, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_38) == 0) +{ +lean_object* x_39; lean_object* x_40; +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; uint8_t x_43; +x_41 = lean_ctor_get(x_40, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_41, 0); +lean_inc(x_42); +x_43 = lean_unbox(x_42); +lean_dec(x_42); +if (x_43 == 0) +{ +lean_object* x_44; uint8_t x_45; +x_44 = lean_ctor_get(x_38, 1); +lean_inc(x_44); +lean_dec(x_38); +x_45 = !lean_is_exclusive(x_39); +if (x_45 == 0) +{ +lean_object* x_46; uint8_t x_47; +x_46 = lean_ctor_get(x_39, 0); +lean_dec(x_46); +x_47 = !lean_is_exclusive(x_40); +if (x_47 == 0) +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_40, 0); +lean_dec(x_48); +x_49 = lean_ctor_get(x_41, 1); +lean_inc(x_49); +lean_dec(x_41); +x_50 = lean_ctor_get(x_49, 1); +lean_inc(x_50); +lean_dec(x_49); +lean_ctor_set(x_40, 0, x_50); +x_13 = x_39; +x_14 = x_44; +goto block_36; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_51 = lean_ctor_get(x_40, 1); +lean_inc(x_51); +lean_dec(x_40); +x_52 = lean_ctor_get(x_41, 1); +lean_inc(x_52); +lean_dec(x_41); +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_51); +lean_ctor_set(x_39, 0, x_54); +x_13 = x_39; +x_14 = x_44; +goto block_36; +} +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_55 = lean_ctor_get(x_39, 1); +lean_inc(x_55); +lean_dec(x_39); +x_56 = lean_ctor_get(x_40, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_57 = x_40; +} else { + lean_dec_ref(x_40); + x_57 = lean_box(0); +} +x_58 = lean_ctor_get(x_41, 1); +lean_inc(x_58); +lean_dec(x_41); +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +if (lean_is_scalar(x_57)) { + x_60 = lean_alloc_ctor(0, 2, 0); +} else { + x_60 = x_57; +} +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_56); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_55); +x_13 = x_61; +x_14 = x_44; +goto block_36; +} +} +else +{ +lean_object* x_62; uint8_t x_63; +lean_dec(x_41); +x_62 = lean_ctor_get(x_38, 1); +lean_inc(x_62); +lean_dec(x_38); +x_63 = !lean_is_exclusive(x_39); +if (x_63 == 0) +{ +lean_object* x_64; uint8_t x_65; +x_64 = lean_ctor_get(x_39, 0); +lean_dec(x_64); +x_65 = !lean_is_exclusive(x_40); +if (x_65 == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_40, 1); +x_67 = lean_ctor_get(x_40, 0); +lean_dec(x_67); +x_68 = lean_array_get_size(x_66); +lean_ctor_set_tag(x_40, 1); +lean_ctor_set(x_40, 0, x_68); +x_13 = x_39; +x_14 = x_62; +goto block_36; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_40, 1); +lean_inc(x_69); +lean_dec(x_40); +x_70 = lean_array_get_size(x_69); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_69); +lean_ctor_set(x_39, 0, x_71); +x_13 = x_39; +x_14 = x_62; +goto block_36; +} +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_72 = lean_ctor_get(x_39, 1); +lean_inc(x_72); +lean_dec(x_39); +x_73 = lean_ctor_get(x_40, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_74 = x_40; +} else { + lean_dec_ref(x_40); + x_74 = lean_box(0); +} +x_75 = lean_array_get_size(x_73); +if (lean_is_scalar(x_74)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_74; + lean_ctor_set_tag(x_76, 1); +} +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_73); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_72); +x_13 = x_77; +x_14 = x_62; +goto block_36; +} +} +} +else +{ +lean_object* x_78; uint8_t x_79; +x_78 = lean_ctor_get(x_38, 1); +lean_inc(x_78); +lean_dec(x_38); +x_79 = !lean_is_exclusive(x_39); +if (x_79 == 0) +{ +lean_object* x_80; uint8_t x_81; +x_80 = lean_ctor_get(x_39, 0); +lean_dec(x_80); +x_81 = !lean_is_exclusive(x_40); +if (x_81 == 0) +{ +x_13 = x_39; +x_14 = x_78; +goto block_36; +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_82 = lean_ctor_get(x_40, 0); +x_83 = lean_ctor_get(x_40, 1); +lean_inc(x_83); +lean_inc(x_82); +lean_dec(x_40); +x_84 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_84, 0, x_82); +lean_ctor_set(x_84, 1, x_83); +lean_ctor_set(x_39, 0, x_84); +x_13 = x_39; +x_14 = x_78; +goto block_36; +} +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_85 = lean_ctor_get(x_39, 1); +lean_inc(x_85); +lean_dec(x_39); +x_86 = lean_ctor_get(x_40, 0); +lean_inc(x_86); +x_87 = lean_ctor_get(x_40, 1); +lean_inc(x_87); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_88 = x_40; +} else { + lean_dec_ref(x_40); + x_88 = lean_box(0); +} +if (lean_is_scalar(x_88)) { + x_89 = lean_alloc_ctor(1, 2, 0); +} else { + x_89 = x_88; +} +lean_ctor_set(x_89, 0, x_86); +lean_ctor_set(x_89, 1, x_87); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_85); +x_13 = x_90; +x_14 = x_78; +goto block_36; +} +} +} +else +{ +uint8_t x_91; +lean_dec(x_12); +x_91 = !lean_is_exclusive(x_38); +if (x_91 == 0) +{ +return x_38; +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_92 = lean_ctor_get(x_38, 0); +x_93 = lean_ctor_get(x_38, 1); +lean_inc(x_93); +lean_inc(x_92); +lean_dec(x_38); +x_94 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_94, 0, x_92); +lean_ctor_set(x_94, 1, x_93); +return x_94; +} +} +block_36: +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_13, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_12); +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_13, 0); +lean_dec(x_17); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_13); +lean_ctor_set(x_18, 1, x_14); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_13, 1); +lean_inc(x_19); +lean_dec(x_13); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_15); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_14); +return x_21; +} +} +else +{ +uint8_t x_22; +x_22 = !lean_is_exclusive(x_13); +if (x_22 == 0) +{ +lean_object* x_23; uint8_t x_24; +x_23 = lean_ctor_get(x_13, 0); +lean_dec(x_23); +x_24 = !lean_is_exclusive(x_15); +if (x_24 == 0) +{ +lean_object* x_25; lean_object* x_26; +x_25 = lean_ctor_get(x_15, 0); +lean_dec(x_25); +lean_ctor_set(x_15, 0, x_12); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_13); +lean_ctor_set(x_26, 1, x_14); +return x_26; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_15, 1); +lean_inc(x_27); +lean_dec(x_15); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_12); +lean_ctor_set(x_28, 1, x_27); +lean_ctor_set(x_13, 0, x_28); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_13); +lean_ctor_set(x_29, 1, x_14); +return x_29; +} +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_30 = lean_ctor_get(x_13, 1); +lean_inc(x_30); +lean_dec(x_13); +x_31 = lean_ctor_get(x_15, 1); +lean_inc(x_31); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_32 = x_15; +} else { + lean_dec_ref(x_15); + x_32 = lean_box(0); +} +if (lean_is_scalar(x_32)) { + x_33 = lean_alloc_ctor(1, 2, 0); +} else { + x_33 = x_32; +} +lean_ctor_set(x_33, 0, x_12); +lean_ctor_set(x_33, 1, x_31); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_30); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_14); +return x_35; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +lean_dec(x_1); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_computePrecompileImportsAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_computePrecompileImportsAux(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_2); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputePrecompileImports___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_55; lean_object* x_56; uint8_t x_100; +x_100 = lean_usize_dec_lt(x_4, x_3); +if (x_100 == 0) +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_5); +lean_ctor_set(x_101, 1, x_9); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_10); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_11); +return x_103; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_184; lean_object* x_185; lean_object* x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; +x_104 = lean_array_uget(x_2, x_4); +x_105 = lean_ctor_get(x_5, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_5, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_107 = x_5; +} else { + lean_dec_ref(x_5); + x_107 = lean_box(0); +} +x_246 = lean_ctor_get(x_104, 0); +lean_inc(x_246); +x_247 = lean_ctor_get(x_246, 0); +lean_inc(x_247); +x_248 = lean_ctor_get(x_247, 2); +lean_inc(x_248); +lean_dec(x_247); +x_249 = lean_ctor_get_uint8(x_248, sizeof(void*)*21); +lean_dec(x_248); +if (x_249 == 0) +{ +lean_object* x_250; uint8_t x_251; +x_250 = lean_ctor_get(x_246, 1); +lean_inc(x_250); +lean_dec(x_246); +x_251 = lean_ctor_get_uint8(x_250, sizeof(void*)*9); +lean_dec(x_250); +if (x_251 == 0) +{ +lean_object* x_252; lean_object* x_253; lean_object* x_254; +x_252 = l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2; +lean_inc(x_104); +x_253 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_253, 0, x_104); +lean_ctor_set(x_253, 1, x_252); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_254 = lean_apply_6(x_6, x_253, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_254) == 0) +{ +lean_object* x_255; lean_object* x_256; +x_255 = lean_ctor_get(x_254, 0); +lean_inc(x_255); +x_256 = lean_ctor_get(x_255, 0); +lean_inc(x_256); +if (lean_obj_tag(x_256) == 0) +{ +lean_object* x_257; uint8_t x_258; +x_257 = lean_ctor_get(x_254, 1); +lean_inc(x_257); +lean_dec(x_254); +x_258 = !lean_is_exclusive(x_255); +if (x_258 == 0) +{ +lean_object* x_259; lean_object* x_260; uint8_t x_261; +x_259 = lean_ctor_get(x_255, 1); +x_260 = lean_ctor_get(x_255, 0); +lean_dec(x_260); +x_261 = !lean_is_exclusive(x_256); +if (x_261 == 0) +{ +lean_object* x_262; uint8_t x_263; lean_object* x_264; lean_object* x_265; +x_262 = lean_ctor_get(x_256, 0); +x_263 = 0; +x_264 = lean_box(x_263); +lean_ctor_set(x_255, 1, x_262); +lean_ctor_set(x_255, 0, x_264); +lean_ctor_set(x_256, 0, x_255); +x_265 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_265, 0, x_256); +lean_ctor_set(x_265, 1, x_259); +x_184 = x_265; +x_185 = x_257; +goto block_245; +} +else +{ +lean_object* x_266; lean_object* x_267; uint8_t x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; +x_266 = lean_ctor_get(x_256, 0); +x_267 = lean_ctor_get(x_256, 1); +lean_inc(x_267); +lean_inc(x_266); +lean_dec(x_256); +x_268 = 0; +x_269 = lean_box(x_268); +lean_ctor_set(x_255, 1, x_266); +lean_ctor_set(x_255, 0, x_269); +x_270 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_270, 0, x_255); +lean_ctor_set(x_270, 1, x_267); +x_271 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_271, 0, x_270); +lean_ctor_set(x_271, 1, x_259); +x_184 = x_271; +x_185 = x_257; +goto block_245; +} +} +else +{ +lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; uint8_t x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; +x_272 = lean_ctor_get(x_255, 1); +lean_inc(x_272); +lean_dec(x_255); +x_273 = lean_ctor_get(x_256, 0); +lean_inc(x_273); +x_274 = lean_ctor_get(x_256, 1); +lean_inc(x_274); +if (lean_is_exclusive(x_256)) { + lean_ctor_release(x_256, 0); + lean_ctor_release(x_256, 1); + x_275 = x_256; +} else { + lean_dec_ref(x_256); + x_275 = lean_box(0); +} +x_276 = 0; +x_277 = lean_box(x_276); +x_278 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_278, 0, x_277); +lean_ctor_set(x_278, 1, x_273); +if (lean_is_scalar(x_275)) { + x_279 = lean_alloc_ctor(0, 2, 0); +} else { + x_279 = x_275; +} +lean_ctor_set(x_279, 0, x_278); +lean_ctor_set(x_279, 1, x_274); +x_280 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_280, 0, x_279); +lean_ctor_set(x_280, 1, x_272); +x_184 = x_280; +x_185 = x_257; +goto block_245; +} +} +else +{ +lean_object* x_281; uint8_t x_282; +x_281 = lean_ctor_get(x_254, 1); +lean_inc(x_281); +lean_dec(x_254); +x_282 = !lean_is_exclusive(x_255); +if (x_282 == 0) +{ +lean_object* x_283; uint8_t x_284; +x_283 = lean_ctor_get(x_255, 0); +lean_dec(x_283); +x_284 = !lean_is_exclusive(x_256); +if (x_284 == 0) +{ +x_184 = x_255; +x_185 = x_281; +goto block_245; +} +else +{ +lean_object* x_285; lean_object* x_286; lean_object* x_287; +x_285 = lean_ctor_get(x_256, 0); +x_286 = lean_ctor_get(x_256, 1); +lean_inc(x_286); +lean_inc(x_285); +lean_dec(x_256); +x_287 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_287, 0, x_285); +lean_ctor_set(x_287, 1, x_286); +lean_ctor_set(x_255, 0, x_287); +x_184 = x_255; +x_185 = x_281; +goto block_245; +} +} +else +{ +lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; +x_288 = lean_ctor_get(x_255, 1); +lean_inc(x_288); +lean_dec(x_255); +x_289 = lean_ctor_get(x_256, 0); +lean_inc(x_289); +x_290 = lean_ctor_get(x_256, 1); +lean_inc(x_290); +if (lean_is_exclusive(x_256)) { + lean_ctor_release(x_256, 0); + lean_ctor_release(x_256, 1); + x_291 = x_256; +} else { + lean_dec_ref(x_256); + x_291 = lean_box(0); +} +if (lean_is_scalar(x_291)) { + x_292 = lean_alloc_ctor(1, 2, 0); +} else { + x_292 = x_291; +} +lean_ctor_set(x_292, 0, x_289); +lean_ctor_set(x_292, 1, x_290); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_288); +x_184 = x_293; +x_185 = x_281; +goto block_245; +} +} +} +else +{ +uint8_t x_294; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_294 = !lean_is_exclusive(x_254); +if (x_294 == 0) +{ +return x_254; +} +else +{ +lean_object* x_295; lean_object* x_296; lean_object* x_297; +x_295 = lean_ctor_get(x_254, 0); +x_296 = lean_ctor_get(x_254, 1); +lean_inc(x_296); +lean_inc(x_295); +lean_dec(x_254); +x_297 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_297, 0, x_295); +lean_ctor_set(x_297, 1, x_296); +return x_297; +} +} +} +else +{ +lean_object* x_298; lean_object* x_299; lean_object* x_300; +x_298 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +lean_inc(x_104); +x_299 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_299, 0, x_104); +lean_ctor_set(x_299, 1, x_298); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_300 = lean_apply_6(x_6, x_299, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_300) == 0) +{ +lean_object* x_301; lean_object* x_302; +x_301 = lean_ctor_get(x_300, 0); +lean_inc(x_301); +x_302 = lean_ctor_get(x_301, 0); +lean_inc(x_302); +if (lean_obj_tag(x_302) == 0) +{ +lean_object* x_303; uint8_t x_304; +x_303 = lean_ctor_get(x_300, 1); +lean_inc(x_303); +lean_dec(x_300); +x_304 = !lean_is_exclusive(x_301); +if (x_304 == 0) +{ +lean_object* x_305; lean_object* x_306; uint8_t x_307; +x_305 = lean_ctor_get(x_301, 1); +x_306 = lean_ctor_get(x_301, 0); +lean_dec(x_306); +x_307 = !lean_is_exclusive(x_302); +if (x_307 == 0) +{ +lean_object* x_308; uint8_t x_309; lean_object* x_310; lean_object* x_311; +x_308 = lean_ctor_get(x_302, 0); +x_309 = 1; +x_310 = lean_box(x_309); +lean_ctor_set(x_301, 1, x_308); +lean_ctor_set(x_301, 0, x_310); +lean_ctor_set(x_302, 0, x_301); +x_311 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_311, 0, x_302); +lean_ctor_set(x_311, 1, x_305); +x_184 = x_311; +x_185 = x_303; +goto block_245; +} +else +{ +lean_object* x_312; lean_object* x_313; uint8_t x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; +x_312 = lean_ctor_get(x_302, 0); +x_313 = lean_ctor_get(x_302, 1); +lean_inc(x_313); +lean_inc(x_312); +lean_dec(x_302); +x_314 = 1; +x_315 = lean_box(x_314); +lean_ctor_set(x_301, 1, x_312); +lean_ctor_set(x_301, 0, x_315); +x_316 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_316, 0, x_301); +lean_ctor_set(x_316, 1, x_313); +x_317 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_317, 0, x_316); +lean_ctor_set(x_317, 1, x_305); +x_184 = x_317; +x_185 = x_303; +goto block_245; +} +} +else +{ +lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; uint8_t x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; +x_318 = lean_ctor_get(x_301, 1); +lean_inc(x_318); +lean_dec(x_301); +x_319 = lean_ctor_get(x_302, 0); +lean_inc(x_319); +x_320 = lean_ctor_get(x_302, 1); +lean_inc(x_320); +if (lean_is_exclusive(x_302)) { + lean_ctor_release(x_302, 0); + lean_ctor_release(x_302, 1); + x_321 = x_302; +} else { + lean_dec_ref(x_302); + x_321 = lean_box(0); +} +x_322 = 1; +x_323 = lean_box(x_322); +x_324 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_324, 0, x_323); +lean_ctor_set(x_324, 1, x_319); +if (lean_is_scalar(x_321)) { + x_325 = lean_alloc_ctor(0, 2, 0); +} else { + x_325 = x_321; +} +lean_ctor_set(x_325, 0, x_324); +lean_ctor_set(x_325, 1, x_320); +x_326 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_326, 0, x_325); +lean_ctor_set(x_326, 1, x_318); +x_184 = x_326; +x_185 = x_303; +goto block_245; +} +} +else +{ +lean_object* x_327; uint8_t x_328; +x_327 = lean_ctor_get(x_300, 1); +lean_inc(x_327); +lean_dec(x_300); +x_328 = !lean_is_exclusive(x_301); +if (x_328 == 0) +{ +lean_object* x_329; uint8_t x_330; +x_329 = lean_ctor_get(x_301, 0); +lean_dec(x_329); +x_330 = !lean_is_exclusive(x_302); +if (x_330 == 0) +{ +x_184 = x_301; +x_185 = x_327; +goto block_245; +} +else +{ +lean_object* x_331; lean_object* x_332; lean_object* x_333; +x_331 = lean_ctor_get(x_302, 0); +x_332 = lean_ctor_get(x_302, 1); +lean_inc(x_332); +lean_inc(x_331); +lean_dec(x_302); +x_333 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_333, 0, x_331); +lean_ctor_set(x_333, 1, x_332); +lean_ctor_set(x_301, 0, x_333); +x_184 = x_301; +x_185 = x_327; +goto block_245; +} +} +else +{ +lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; +x_334 = lean_ctor_get(x_301, 1); +lean_inc(x_334); +lean_dec(x_301); +x_335 = lean_ctor_get(x_302, 0); +lean_inc(x_335); +x_336 = lean_ctor_get(x_302, 1); +lean_inc(x_336); +if (lean_is_exclusive(x_302)) { + lean_ctor_release(x_302, 0); + lean_ctor_release(x_302, 1); + x_337 = x_302; +} else { + lean_dec_ref(x_302); + x_337 = lean_box(0); +} +if (lean_is_scalar(x_337)) { + x_338 = lean_alloc_ctor(1, 2, 0); +} else { + x_338 = x_337; +} +lean_ctor_set(x_338, 0, x_335); +lean_ctor_set(x_338, 1, x_336); +x_339 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_339, 0, x_338); +lean_ctor_set(x_339, 1, x_334); +x_184 = x_339; +x_185 = x_327; +goto block_245; +} +} +} +else +{ +uint8_t x_340; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_340 = !lean_is_exclusive(x_300); +if (x_340 == 0) +{ +return x_300; +} +else +{ +lean_object* x_341; lean_object* x_342; lean_object* x_343; +x_341 = lean_ctor_get(x_300, 0); +x_342 = lean_ctor_get(x_300, 1); +lean_inc(x_342); +lean_inc(x_341); +lean_dec(x_300); +x_343 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_343, 0, x_341); +lean_ctor_set(x_343, 1, x_342); +return x_343; +} +} +} +} +else +{ +lean_object* x_344; lean_object* x_345; lean_object* x_346; +lean_dec(x_246); +x_344 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +lean_inc(x_104); +x_345 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_345, 0, x_104); +lean_ctor_set(x_345, 1, x_344); +lean_inc(x_6); +lean_inc(x_8); +lean_inc(x_7); +x_346 = lean_apply_6(x_6, x_345, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_346) == 0) +{ +lean_object* x_347; lean_object* x_348; +x_347 = lean_ctor_get(x_346, 0); +lean_inc(x_347); +x_348 = lean_ctor_get(x_347, 0); +lean_inc(x_348); +if (lean_obj_tag(x_348) == 0) +{ +lean_object* x_349; uint8_t x_350; +x_349 = lean_ctor_get(x_346, 1); +lean_inc(x_349); +lean_dec(x_346); +x_350 = !lean_is_exclusive(x_347); +if (x_350 == 0) +{ +lean_object* x_351; lean_object* x_352; uint8_t x_353; +x_351 = lean_ctor_get(x_347, 1); +x_352 = lean_ctor_get(x_347, 0); +lean_dec(x_352); +x_353 = !lean_is_exclusive(x_348); +if (x_353 == 0) +{ +lean_object* x_354; uint8_t x_355; lean_object* x_356; lean_object* x_357; +x_354 = lean_ctor_get(x_348, 0); +x_355 = 1; +x_356 = lean_box(x_355); +lean_ctor_set(x_347, 1, x_354); +lean_ctor_set(x_347, 0, x_356); +lean_ctor_set(x_348, 0, x_347); +x_357 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_357, 0, x_348); +lean_ctor_set(x_357, 1, x_351); +x_184 = x_357; +x_185 = x_349; +goto block_245; +} +else +{ +lean_object* x_358; lean_object* x_359; uint8_t x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; +x_358 = lean_ctor_get(x_348, 0); +x_359 = lean_ctor_get(x_348, 1); +lean_inc(x_359); +lean_inc(x_358); +lean_dec(x_348); +x_360 = 1; +x_361 = lean_box(x_360); +lean_ctor_set(x_347, 1, x_358); +lean_ctor_set(x_347, 0, x_361); +x_362 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_362, 0, x_347); +lean_ctor_set(x_362, 1, x_359); +x_363 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_363, 0, x_362); +lean_ctor_set(x_363, 1, x_351); +x_184 = x_363; +x_185 = x_349; +goto block_245; +} +} +else +{ +lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; uint8_t x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; +x_364 = lean_ctor_get(x_347, 1); +lean_inc(x_364); +lean_dec(x_347); +x_365 = lean_ctor_get(x_348, 0); +lean_inc(x_365); +x_366 = lean_ctor_get(x_348, 1); +lean_inc(x_366); +if (lean_is_exclusive(x_348)) { + lean_ctor_release(x_348, 0); + lean_ctor_release(x_348, 1); + x_367 = x_348; +} else { + lean_dec_ref(x_348); + x_367 = lean_box(0); +} +x_368 = 1; +x_369 = lean_box(x_368); +x_370 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_370, 0, x_369); +lean_ctor_set(x_370, 1, x_365); +if (lean_is_scalar(x_367)) { + x_371 = lean_alloc_ctor(0, 2, 0); +} else { + x_371 = x_367; +} +lean_ctor_set(x_371, 0, x_370); +lean_ctor_set(x_371, 1, x_366); +x_372 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_372, 0, x_371); +lean_ctor_set(x_372, 1, x_364); +x_184 = x_372; +x_185 = x_349; +goto block_245; +} +} +else +{ +lean_object* x_373; uint8_t x_374; +x_373 = lean_ctor_get(x_346, 1); +lean_inc(x_373); +lean_dec(x_346); +x_374 = !lean_is_exclusive(x_347); +if (x_374 == 0) +{ +lean_object* x_375; uint8_t x_376; +x_375 = lean_ctor_get(x_347, 0); +lean_dec(x_375); +x_376 = !lean_is_exclusive(x_348); +if (x_376 == 0) +{ +x_184 = x_347; +x_185 = x_373; +goto block_245; +} +else +{ +lean_object* x_377; lean_object* x_378; lean_object* x_379; +x_377 = lean_ctor_get(x_348, 0); +x_378 = lean_ctor_get(x_348, 1); +lean_inc(x_378); +lean_inc(x_377); +lean_dec(x_348); +x_379 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_379, 0, x_377); +lean_ctor_set(x_379, 1, x_378); +lean_ctor_set(x_347, 0, x_379); +x_184 = x_347; +x_185 = x_373; +goto block_245; +} +} +else +{ +lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; +x_380 = lean_ctor_get(x_347, 1); +lean_inc(x_380); +lean_dec(x_347); +x_381 = lean_ctor_get(x_348, 0); +lean_inc(x_381); +x_382 = lean_ctor_get(x_348, 1); +lean_inc(x_382); +if (lean_is_exclusive(x_348)) { + lean_ctor_release(x_348, 0); + lean_ctor_release(x_348, 1); + x_383 = x_348; +} else { + lean_dec_ref(x_348); + x_383 = lean_box(0); +} +if (lean_is_scalar(x_383)) { + x_384 = lean_alloc_ctor(1, 2, 0); +} else { + x_384 = x_383; +} +lean_ctor_set(x_384, 0, x_381); +lean_ctor_set(x_384, 1, x_382); +x_385 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_385, 0, x_384); +lean_ctor_set(x_385, 1, x_380); +x_184 = x_385; +x_185 = x_373; +goto block_245; +} +} +} +else +{ +uint8_t x_386; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +lean_dec(x_104); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_386 = !lean_is_exclusive(x_346); +if (x_386 == 0) +{ +return x_346; +} +else +{ +lean_object* x_387; lean_object* x_388; lean_object* x_389; +x_387 = lean_ctor_get(x_346, 0); +x_388 = lean_ctor_get(x_346, 1); +lean_inc(x_388); +lean_inc(x_387); +lean_dec(x_346); +x_389 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_389, 0, x_387); +lean_ctor_set(x_389, 1, x_388); +return x_389; +} +} +} +block_183: +{ +lean_object* x_110; +x_110 = lean_ctor_get(x_108, 0); +lean_inc(x_110); +if (lean_obj_tag(x_110) == 0) +{ +uint8_t x_111; +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_104); +x_111 = !lean_is_exclusive(x_108); +if (x_111 == 0) +{ +lean_object* x_112; +x_112 = lean_ctor_get(x_108, 0); +lean_dec(x_112); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_113; lean_object* x_114; +x_113 = lean_ctor_get(x_108, 1); +lean_inc(x_113); +lean_dec(x_108); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_110); +lean_ctor_set(x_114, 1, x_113); +x_55 = x_114; +x_56 = x_109; +goto block_99; +} +} +else +{ +uint8_t x_115; +x_115 = !lean_is_exclusive(x_108); +if (x_115 == 0) +{ +lean_object* x_116; uint8_t x_117; +x_116 = lean_ctor_get(x_108, 0); +lean_dec(x_116); +x_117 = !lean_is_exclusive(x_110); +if (x_117 == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_118 = lean_ctor_get(x_110, 0); +x_119 = lean_ctor_get(x_110, 1); +x_120 = l_Array_shrink___rarg(x_119, x_118); +lean_dec(x_118); +x_121 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_122 = lean_string_append(x_121, x_1); +x_123 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_124 = lean_string_append(x_122, x_123); +x_125 = lean_ctor_get(x_104, 1); +lean_inc(x_125); +lean_dec(x_104); +x_126 = 1; +x_127 = l_Lean_Name_toString(x_125, x_126); +x_128 = lean_string_append(x_124, x_127); +lean_dec(x_127); +x_129 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_130 = lean_string_append(x_128, x_129); +x_131 = 3; +x_132 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set_uint8(x_132, sizeof(void*)*1, x_131); +x_133 = lean_array_push(x_120, x_132); +x_134 = lean_box(x_126); +if (lean_is_scalar(x_107)) { + x_135 = lean_alloc_ctor(0, 2, 0); +} else { + x_135 = x_107; +} +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_106); +x_136 = lean_box(0); +x_137 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_135); +lean_ctor_set_tag(x_110, 0); +lean_ctor_set(x_110, 1, x_133); +lean_ctor_set(x_110, 0, x_137); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +x_138 = lean_ctor_get(x_110, 0); +x_139 = lean_ctor_get(x_110, 1); +lean_inc(x_139); +lean_inc(x_138); +lean_dec(x_110); +x_140 = l_Array_shrink___rarg(x_139, x_138); +lean_dec(x_138); +x_141 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_142 = lean_string_append(x_141, x_1); +x_143 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_144 = lean_string_append(x_142, x_143); +x_145 = lean_ctor_get(x_104, 1); +lean_inc(x_145); +lean_dec(x_104); +x_146 = 1; +x_147 = l_Lean_Name_toString(x_145, x_146); +x_148 = lean_string_append(x_144, x_147); +lean_dec(x_147); +x_149 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_150 = lean_string_append(x_148, x_149); +x_151 = 3; +x_152 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set_uint8(x_152, sizeof(void*)*1, x_151); +x_153 = lean_array_push(x_140, x_152); +x_154 = lean_box(x_146); +if (lean_is_scalar(x_107)) { + x_155 = lean_alloc_ctor(0, 2, 0); +} else { + x_155 = x_107; +} +lean_ctor_set(x_155, 0, x_154); +lean_ctor_set(x_155, 1, x_106); +x_156 = lean_box(0); +x_157 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_157, 0, x_156); +lean_ctor_set(x_157, 1, x_155); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_157); +lean_ctor_set(x_158, 1, x_153); +lean_ctor_set(x_108, 0, x_158); +x_55 = x_108; +x_56 = x_109; +goto block_99; +} +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; uint8_t x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; +x_159 = lean_ctor_get(x_108, 1); +lean_inc(x_159); +lean_dec(x_108); +x_160 = lean_ctor_get(x_110, 0); +lean_inc(x_160); +x_161 = lean_ctor_get(x_110, 1); +lean_inc(x_161); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_162 = x_110; +} else { + lean_dec_ref(x_110); + x_162 = lean_box(0); +} +x_163 = l_Array_shrink___rarg(x_161, x_160); +lean_dec(x_160); +x_164 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_165 = lean_string_append(x_164, x_1); +x_166 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2; +x_167 = lean_string_append(x_165, x_166); +x_168 = lean_ctor_get(x_104, 1); +lean_inc(x_168); +lean_dec(x_104); +x_169 = 1; +x_170 = l_Lean_Name_toString(x_168, x_169); +x_171 = lean_string_append(x_167, x_170); +lean_dec(x_170); +x_172 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3; +x_173 = lean_string_append(x_171, x_172); +x_174 = 3; +x_175 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_175, 0, x_173); +lean_ctor_set_uint8(x_175, sizeof(void*)*1, x_174); +x_176 = lean_array_push(x_163, x_175); +x_177 = lean_box(x_169); +if (lean_is_scalar(x_107)) { + x_178 = lean_alloc_ctor(0, 2, 0); +} else { + x_178 = x_107; +} +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_106); +x_179 = lean_box(0); +x_180 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_178); +if (lean_is_scalar(x_162)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_162; + lean_ctor_set_tag(x_181, 0); +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_176); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_159); +x_55 = x_182; +x_56 = x_109; +goto block_99; +} +} +} +block_245: +{ +lean_object* x_186; +x_186 = lean_ctor_get(x_184, 0); +lean_inc(x_186); +if (lean_obj_tag(x_186) == 0) +{ +lean_object* x_187; lean_object* x_188; uint8_t x_189; +x_187 = lean_ctor_get(x_186, 0); +lean_inc(x_187); +x_188 = lean_ctor_get(x_184, 1); +lean_inc(x_188); +lean_dec(x_184); +x_189 = !lean_is_exclusive(x_186); +if (x_189 == 0) +{ +lean_object* x_190; uint8_t x_191; +x_190 = lean_ctor_get(x_186, 0); +lean_dec(x_190); +x_191 = !lean_is_exclusive(x_187); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; +x_192 = lean_ctor_get(x_187, 0); +x_193 = lean_ctor_get(x_187, 1); +lean_inc(x_106); +x_194 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_193); +lean_dec(x_193); +x_195 = lean_unbox(x_192); +lean_dec(x_192); +if (x_195 == 0) +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; +x_196 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_196, 0, x_105); +lean_ctor_set(x_196, 1, x_194); +x_197 = lean_box(0); +x_198 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_196); +lean_ctor_set(x_186, 0, x_198); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; +lean_inc(x_104); +x_199 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_194, x_104); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_105); +lean_ctor_set(x_200, 1, x_199); +x_201 = lean_box(0); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_201); +lean_ctor_set(x_202, 1, x_200); +lean_ctor_set(x_186, 0, x_202); +lean_ctor_set(x_187, 1, x_188); +lean_ctor_set(x_187, 0, x_186); +x_108 = x_187; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_203; lean_object* x_204; lean_object* x_205; uint8_t x_206; +x_203 = lean_ctor_get(x_187, 0); +x_204 = lean_ctor_get(x_187, 1); +lean_inc(x_204); +lean_inc(x_203); +lean_dec(x_187); +lean_inc(x_106); +x_205 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_204); +lean_dec(x_204); +x_206 = lean_unbox(x_203); +lean_dec(x_203); +if (x_206 == 0) +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +x_207 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_207, 0, x_105); +lean_ctor_set(x_207, 1, x_205); +x_208 = lean_box(0); +x_209 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_209, 0, x_208); +lean_ctor_set(x_209, 1, x_207); +lean_ctor_set(x_186, 0, x_209); +x_210 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_210, 0, x_186); +lean_ctor_set(x_210, 1, x_188); +x_108 = x_210; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +lean_inc(x_104); +x_211 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_205, x_104); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_105); +lean_ctor_set(x_212, 1, x_211); +x_213 = lean_box(0); +x_214 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_214, 0, x_213); +lean_ctor_set(x_214, 1, x_212); +lean_ctor_set(x_186, 0, x_214); +x_215 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_215, 0, x_186); +lean_ctor_set(x_215, 1, x_188); +x_108 = x_215; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; uint8_t x_221; +x_216 = lean_ctor_get(x_186, 1); +lean_inc(x_216); +lean_dec(x_186); +x_217 = lean_ctor_get(x_187, 0); +lean_inc(x_217); +x_218 = lean_ctor_get(x_187, 1); +lean_inc(x_218); +if (lean_is_exclusive(x_187)) { + lean_ctor_release(x_187, 0); + lean_ctor_release(x_187, 1); + x_219 = x_187; +} else { + lean_dec_ref(x_187); + x_219 = lean_box(0); +} +lean_inc(x_106); +x_220 = l_Lake_OrdHashSet_appendArray___at_Lake_collectImportsAux___spec__1(x_106, x_218); +lean_dec(x_218); +x_221 = lean_unbox(x_217); +lean_dec(x_217); +if (x_221 == 0) +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_222 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_222, 0, x_105); +lean_ctor_set(x_222, 1, x_220); +x_223 = lean_box(0); +x_224 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_224, 0, x_223); +lean_ctor_set(x_224, 1, x_222); +x_225 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_225, 0, x_224); +lean_ctor_set(x_225, 1, x_216); +if (lean_is_scalar(x_219)) { + x_226 = lean_alloc_ctor(0, 2, 0); +} else { + x_226 = x_219; +} +lean_ctor_set(x_226, 0, x_225); +lean_ctor_set(x_226, 1, x_188); +x_108 = x_226; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +lean_inc(x_104); +x_227 = l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2(x_220, x_104); +x_228 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_228, 0, x_105); +lean_ctor_set(x_228, 1, x_227); +x_229 = lean_box(0); +x_230 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_230, 0, x_229); +lean_ctor_set(x_230, 1, x_228); +x_231 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_231, 0, x_230); +lean_ctor_set(x_231, 1, x_216); +if (lean_is_scalar(x_219)) { + x_232 = lean_alloc_ctor(0, 2, 0); +} else { + x_232 = x_219; +} +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_188); +x_108 = x_232; +x_109 = x_185; +goto block_183; +} +} +} +else +{ +uint8_t x_233; +lean_dec(x_105); +x_233 = !lean_is_exclusive(x_184); +if (x_233 == 0) +{ +lean_object* x_234; uint8_t x_235; +x_234 = lean_ctor_get(x_184, 0); +lean_dec(x_234); +x_235 = !lean_is_exclusive(x_186); +if (x_235 == 0) +{ +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +else +{ +lean_object* x_236; lean_object* x_237; lean_object* x_238; +x_236 = lean_ctor_get(x_186, 0); +x_237 = lean_ctor_get(x_186, 1); +lean_inc(x_237); +lean_inc(x_236); +lean_dec(x_186); +x_238 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_238, 0, x_236); +lean_ctor_set(x_238, 1, x_237); +lean_ctor_set(x_184, 0, x_238); +x_108 = x_184; +x_109 = x_185; +goto block_183; +} +} +else +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_239 = lean_ctor_get(x_184, 1); +lean_inc(x_239); +lean_dec(x_184); +x_240 = lean_ctor_get(x_186, 0); +lean_inc(x_240); +x_241 = lean_ctor_get(x_186, 1); +lean_inc(x_241); +if (lean_is_exclusive(x_186)) { + lean_ctor_release(x_186, 0); + lean_ctor_release(x_186, 1); + x_242 = x_186; +} else { + lean_dec_ref(x_186); + x_242 = lean_box(0); +} +if (lean_is_scalar(x_242)) { + x_243 = lean_alloc_ctor(1, 2, 0); +} else { + x_243 = x_242; +} +lean_ctor_set(x_243, 0, x_240); +lean_ctor_set(x_243, 1, x_241); +x_244 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_244, 0, x_243); +lean_ctor_set(x_244, 1, x_239); +x_108 = x_244; +x_109 = x_185; +goto block_183; +} +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +block_99: +{ +lean_object* x_57; +x_57 = lean_ctor_get(x_55, 0); +lean_inc(x_57); +if (lean_obj_tag(x_57) == 0) +{ +lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_58 = lean_ctor_get(x_57, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = !lean_is_exclusive(x_55); +if (x_60 == 0) +{ +lean_object* x_61; uint8_t x_62; +x_61 = lean_ctor_get(x_55, 0); +lean_dec(x_61); +x_62 = !lean_is_exclusive(x_57); +if (x_62 == 0) +{ +lean_object* x_63; uint8_t x_64; +x_63 = lean_ctor_get(x_57, 0); +lean_dec(x_63); +x_64 = !lean_is_exclusive(x_59); +if (x_64 == 0) +{ +lean_object* x_65; +x_65 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_65, 0, x_59); +lean_ctor_set(x_57, 0, x_65); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_66 = lean_ctor_get(x_59, 0); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_59); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +x_69 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_57, 0, x_69); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_70 = lean_ctor_get(x_57, 1); +lean_inc(x_70); +lean_dec(x_57); +x_71 = lean_ctor_get(x_59, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_59, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_73 = x_59; +} else { + lean_dec_ref(x_59); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +x_75 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_75, 0, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_70); +lean_ctor_set(x_55, 0, x_76); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_77 = lean_ctor_get(x_55, 1); +lean_inc(x_77); +lean_dec(x_55); +x_78 = lean_ctor_get(x_57, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_79 = x_57; +} else { + lean_dec_ref(x_57); + x_79 = lean_box(0); +} +x_80 = lean_ctor_get(x_59, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_59, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_82 = x_59; +} else { + lean_dec_ref(x_59); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_82)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_82; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_81); +x_84 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_84, 0, x_83); +if (lean_is_scalar(x_79)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_79; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_78); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_12 = x_86; +x_13 = x_56; +goto block_54; +} +} +else +{ +uint8_t x_87; +x_87 = !lean_is_exclusive(x_55); +if (x_87 == 0) +{ +lean_object* x_88; uint8_t x_89; +x_88 = lean_ctor_get(x_55, 0); +lean_dec(x_88); +x_89 = !lean_is_exclusive(x_57); +if (x_89 == 0) +{ +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_57, 0); +x_91 = lean_ctor_get(x_57, 1); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_57); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set(x_92, 1, x_91); +lean_ctor_set(x_55, 0, x_92); +x_12 = x_55; +x_13 = x_56; +goto block_54; +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_93 = lean_ctor_get(x_55, 1); +lean_inc(x_93); +lean_dec(x_55); +x_94 = lean_ctor_get(x_57, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_57, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_57)) { + lean_ctor_release(x_57, 0); + lean_ctor_release(x_57, 1); + x_96 = x_57; +} else { + lean_dec_ref(x_57); + x_96 = lean_box(0); +} +if (lean_is_scalar(x_96)) { + x_97 = lean_alloc_ctor(1, 2, 0); +} else { + x_97 = x_96; +} +lean_ctor_set(x_97, 0, x_94); +lean_ctor_set(x_97, 1, x_95); +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_93); +x_12 = x_98; +x_13 = x_56; +goto block_54; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recComputePrecompileImports(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Lake_Module_importsFacetConfig___closed__2; +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +x_10 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; size_t x_31; size_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_58; lean_object* x_59; +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_14 = x_10; +} else { + lean_dec_ref(x_10); + x_14 = lean_box(0); +} +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = lean_ctor_get(x_12, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_12, 1); +lean_inc(x_17); +lean_dec(x_12); +x_18 = lean_ctor_get(x_1, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_19, 2); +lean_inc(x_21); +lean_dec(x_19); +x_22 = lean_ctor_get(x_21, 7); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_System_FilePath_join(x_20, x_22); +x_24 = lean_ctor_get(x_18, 1); +lean_inc(x_24); +lean_dec(x_18); +x_25 = lean_ctor_get(x_24, 2); +lean_inc(x_25); +lean_dec(x_24); +x_26 = l_System_FilePath_join(x_23, x_25); +x_27 = lean_ctor_get(x_1, 1); +lean_inc(x_27); +lean_dec(x_1); +x_28 = l_Lake_Module_recParseImports___closed__1; +x_29 = l_Lean_modToFilePath(x_26, x_27, x_28); +lean_dec(x_26); +x_30 = lean_array_get_size(x_16); +x_31 = lean_usize_of_nat(x_30); +lean_dec(x_30); +x_32 = 0; +x_33 = lean_array_get_size(x_17); +x_58 = l_Lake_collectImportsAux___closed__1; +x_59 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputePrecompileImports___spec__1(x_29, x_16, x_31, x_32, x_58, x_2, x_3, x_4, x_17, x_15, x_13); +lean_dec(x_16); +lean_dec(x_29); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; lean_object* x_61; +x_60 = lean_ctor_get(x_59, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +if (lean_obj_tag(x_61) == 0) +{ +lean_object* x_62; lean_object* x_63; uint8_t x_64; +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +x_64 = lean_unbox(x_63); +lean_dec(x_63); +if (x_64 == 0) +{ +lean_object* x_65; uint8_t x_66; +x_65 = lean_ctor_get(x_59, 1); +lean_inc(x_65); +lean_dec(x_59); +x_66 = !lean_is_exclusive(x_60); +if (x_66 == 0) +{ +lean_object* x_67; uint8_t x_68; +x_67 = lean_ctor_get(x_60, 0); +lean_dec(x_67); +x_68 = !lean_is_exclusive(x_61); +if (x_68 == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_61, 0); +lean_dec(x_69); +x_70 = lean_ctor_get(x_62, 1); +lean_inc(x_70); +lean_dec(x_62); +x_71 = lean_ctor_get(x_70, 1); +lean_inc(x_71); +lean_dec(x_70); +lean_ctor_set(x_61, 0, x_71); +x_34 = x_60; +x_35 = x_65; +goto block_57; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_72 = lean_ctor_get(x_61, 1); +lean_inc(x_72); +lean_dec(x_61); +x_73 = lean_ctor_get(x_62, 1); +lean_inc(x_73); +lean_dec(x_62); +x_74 = lean_ctor_get(x_73, 1); +lean_inc(x_74); +lean_dec(x_73); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_72); +lean_ctor_set(x_60, 0, x_75); +x_34 = x_60; +x_35 = x_65; +goto block_57; +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_76 = lean_ctor_get(x_60, 1); +lean_inc(x_76); +lean_dec(x_60); +x_77 = lean_ctor_get(x_61, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_61)) { + lean_ctor_release(x_61, 0); + lean_ctor_release(x_61, 1); + x_78 = x_61; +} else { + lean_dec_ref(x_61); + x_78 = lean_box(0); +} +x_79 = lean_ctor_get(x_62, 1); +lean_inc(x_79); +lean_dec(x_62); +x_80 = lean_ctor_get(x_79, 1); +lean_inc(x_80); +lean_dec(x_79); +if (lean_is_scalar(x_78)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_78; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_77); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_76); +x_34 = x_82; +x_35 = x_65; +goto block_57; +} +} +else +{ +lean_object* x_83; uint8_t x_84; +lean_dec(x_62); +x_83 = lean_ctor_get(x_59, 1); +lean_inc(x_83); +lean_dec(x_59); +x_84 = !lean_is_exclusive(x_60); +if (x_84 == 0) +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_60, 0); +lean_dec(x_85); +x_86 = !lean_is_exclusive(x_61); +if (x_86 == 0) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_61, 1); +x_88 = lean_ctor_get(x_61, 0); +lean_dec(x_88); +x_89 = lean_array_get_size(x_87); +lean_ctor_set_tag(x_61, 1); +lean_ctor_set(x_61, 0, x_89); +x_34 = x_60; +x_35 = x_83; +goto block_57; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_61, 1); +lean_inc(x_90); +lean_dec(x_61); +x_91 = lean_array_get_size(x_90); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_90); +lean_ctor_set(x_60, 0, x_92); +x_34 = x_60; +x_35 = x_83; +goto block_57; +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_93 = lean_ctor_get(x_60, 1); +lean_inc(x_93); +lean_dec(x_60); +x_94 = lean_ctor_get(x_61, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_61)) { + lean_ctor_release(x_61, 0); + lean_ctor_release(x_61, 1); + x_95 = x_61; +} else { + lean_dec_ref(x_61); + x_95 = lean_box(0); +} +x_96 = lean_array_get_size(x_94); +if (lean_is_scalar(x_95)) { + x_97 = lean_alloc_ctor(1, 2, 0); +} else { + x_97 = x_95; + lean_ctor_set_tag(x_97, 1); +} +lean_ctor_set(x_97, 0, x_96); +lean_ctor_set(x_97, 1, x_94); +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_97); +lean_ctor_set(x_98, 1, x_93); +x_34 = x_98; +x_35 = x_83; +goto block_57; +} +} +} +else +{ +lean_object* x_99; uint8_t x_100; +x_99 = lean_ctor_get(x_59, 1); +lean_inc(x_99); +lean_dec(x_59); +x_100 = !lean_is_exclusive(x_60); +if (x_100 == 0) +{ +lean_object* x_101; uint8_t x_102; +x_101 = lean_ctor_get(x_60, 0); +lean_dec(x_101); +x_102 = !lean_is_exclusive(x_61); +if (x_102 == 0) +{ +x_34 = x_60; +x_35 = x_99; +goto block_57; +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; +x_103 = lean_ctor_get(x_61, 0); +x_104 = lean_ctor_get(x_61, 1); +lean_inc(x_104); +lean_inc(x_103); +lean_dec(x_61); +x_105 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_105, 0, x_103); +lean_ctor_set(x_105, 1, x_104); +lean_ctor_set(x_60, 0, x_105); +x_34 = x_60; +x_35 = x_99; +goto block_57; +} +} +else +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_106 = lean_ctor_get(x_60, 1); +lean_inc(x_106); +lean_dec(x_60); +x_107 = lean_ctor_get(x_61, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_61, 1); +lean_inc(x_108); +if (lean_is_exclusive(x_61)) { + lean_ctor_release(x_61, 0); + lean_ctor_release(x_61, 1); + x_109 = x_61; +} else { + lean_dec_ref(x_61); + x_109 = lean_box(0); +} +if (lean_is_scalar(x_109)) { + x_110 = lean_alloc_ctor(1, 2, 0); +} else { + x_110 = x_109; +} +lean_ctor_set(x_110, 0, x_107); +lean_ctor_set(x_110, 1, x_108); +x_111 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_111, 0, x_110); +lean_ctor_set(x_111, 1, x_106); +x_34 = x_111; +x_35 = x_99; +goto block_57; +} +} +} +else +{ +uint8_t x_112; +lean_dec(x_33); +lean_dec(x_14); +x_112 = !lean_is_exclusive(x_59); +if (x_112 == 0) +{ +return x_59; +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_113 = lean_ctor_get(x_59, 0); +x_114 = lean_ctor_get(x_59, 1); +lean_inc(x_114); +lean_inc(x_113); +lean_dec(x_59); +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; +} +} +block_57: +{ +lean_object* x_36; +x_36 = lean_ctor_get(x_34, 0); +lean_inc(x_36); +if (lean_obj_tag(x_36) == 0) +{ +uint8_t x_37; +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +x_38 = lean_ctor_get(x_34, 0); +lean_dec(x_38); +if (lean_is_scalar(x_14)) { + x_39 = lean_alloc_ctor(0, 2, 0); +} else { + x_39 = x_14; +} +lean_ctor_set(x_39, 0, x_34); +lean_ctor_set(x_39, 1, x_35); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_34, 1); +lean_inc(x_40); +lean_dec(x_34); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_36); +lean_ctor_set(x_41, 1, x_40); +if (lean_is_scalar(x_14)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_14; +} +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_35); +return x_42; +} +} +else +{ +uint8_t x_43; +x_43 = !lean_is_exclusive(x_34); +if (x_43 == 0) +{ +lean_object* x_44; uint8_t x_45; +x_44 = lean_ctor_get(x_34, 0); +lean_dec(x_44); +x_45 = !lean_is_exclusive(x_36); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; +x_46 = lean_ctor_get(x_36, 0); +lean_dec(x_46); +lean_ctor_set(x_36, 0, x_33); +if (lean_is_scalar(x_14)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_14; +} +lean_ctor_set(x_47, 0, x_34); +lean_ctor_set(x_47, 1, x_35); +return x_47; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_36, 1); +lean_inc(x_48); +lean_dec(x_36); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_33); +lean_ctor_set(x_49, 1, x_48); +lean_ctor_set(x_34, 0, x_49); +if (lean_is_scalar(x_14)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_14; +} +lean_ctor_set(x_50, 0, x_34); +lean_ctor_set(x_50, 1, x_35); +return x_50; +} +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_51 = lean_ctor_get(x_34, 1); +lean_inc(x_51); +lean_dec(x_34); +x_52 = lean_ctor_get(x_36, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_36)) { + lean_ctor_release(x_36, 0); + lean_ctor_release(x_36, 1); + x_53 = x_36; +} else { + lean_dec_ref(x_36); + x_53 = lean_box(0); +} +if (lean_is_scalar(x_53)) { + x_54 = lean_alloc_ctor(1, 2, 0); +} else { + x_54 = x_53; +} +lean_ctor_set(x_54, 0, x_33); +lean_ctor_set(x_54, 1, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_51); +if (lean_is_scalar(x_14)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_14; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_35); +return x_56; +} +} +} +} +else +{ +uint8_t x_116; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_116 = !lean_is_exclusive(x_10); +if (x_116 == 0) +{ +lean_object* x_117; uint8_t x_118; +x_117 = lean_ctor_get(x_10, 0); +lean_dec(x_117); +x_118 = !lean_is_exclusive(x_11); +if (x_118 == 0) +{ +lean_object* x_119; uint8_t x_120; +x_119 = lean_ctor_get(x_11, 0); +lean_dec(x_119); +x_120 = !lean_is_exclusive(x_12); +if (x_120 == 0) +{ +return x_10; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_121 = lean_ctor_get(x_12, 0); +x_122 = lean_ctor_get(x_12, 1); +lean_inc(x_122); +lean_inc(x_121); +lean_dec(x_12); +x_123 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_123, 0, x_121); +lean_ctor_set(x_123, 1, x_122); +lean_ctor_set(x_11, 0, x_123); +return x_10; +} +} +else +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_124 = lean_ctor_get(x_11, 1); +lean_inc(x_124); +lean_dec(x_11); +x_125 = lean_ctor_get(x_12, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_12, 1); +lean_inc(x_126); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_127 = x_12; +} else { + lean_dec_ref(x_12); + x_127 = lean_box(0); +} +if (lean_is_scalar(x_127)) { + x_128 = lean_alloc_ctor(1, 2, 0); +} else { + x_128 = x_127; +} +lean_ctor_set(x_128, 0, x_125); +lean_ctor_set(x_128, 1, x_126); +x_129 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set(x_129, 1, x_124); +lean_ctor_set(x_10, 0, x_129); +return x_10; +} +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_130 = lean_ctor_get(x_10, 1); +lean_inc(x_130); +lean_dec(x_10); +x_131 = lean_ctor_get(x_11, 1); +lean_inc(x_131); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_132 = x_11; +} else { + lean_dec_ref(x_11); + x_132 = lean_box(0); +} +x_133 = lean_ctor_get(x_12, 0); +lean_inc(x_133); +x_134 = lean_ctor_get(x_12, 1); +lean_inc(x_134); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_135 = x_12; +} else { + lean_dec_ref(x_12); + x_135 = lean_box(0); +} +if (lean_is_scalar(x_135)) { + x_136 = lean_alloc_ctor(1, 2, 0); +} else { + x_136 = x_135; +} +lean_ctor_set(x_136, 0, x_133); +lean_ctor_set(x_136, 1, x_134); +if (lean_is_scalar(x_132)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_132; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_131); +x_138 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_138, 0, x_137); +lean_ctor_set(x_138, 1, x_130); +return x_138; +} +} +} +else +{ +uint8_t x_139; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_139 = !lean_is_exclusive(x_10); +if (x_139 == 0) +{ +return x_10; +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; +x_140 = lean_ctor_get(x_10, 0); +x_141 = lean_ctor_get(x_10, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_10); +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; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Module_recComputePrecompileImports___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputePrecompileImports___spec__1(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +lean_dec(x_1); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_precompileImportsFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Module_recComputePrecompileImports(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +return x_8; +} +} +static lean_object* _init_l_Lake_Module_precompileImportsFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_precompileImportsFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_precompileImportsFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_precompileImportsFacetConfig___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_precompileImportsFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_precompileImportsFacetConfig___closed__2; +return x_1; +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("olean", 5); +return x_1; +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__2; +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +x_11 = lean_apply_6(x_3, x_10, x_4, x_5, x_6, x_7, x_8); +return x_11; +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": module imports itself", 23); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; +x_12 = lean_usize_dec_lt(x_4, x_3); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_5); +lean_ctor_set(x_13, 1, x_9); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_10); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_11); +return x_15; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_16 = lean_array_uget(x_5, x_4); +x_17 = lean_unsigned_to_nat(0u); +x_18 = lean_array_uset(x_5, x_4, x_17); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +x_20 = lean_ctor_get(x_1, 1); +lean_inc(x_20); +x_21 = lean_name_eq(x_19, x_20); +lean_dec(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; +lean_dec(x_20); +x_22 = lean_box(0); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_23 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1(x_16, x_22, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; lean_object* x_25; +x_24 = lean_ctor_get(x_23, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +if (lean_obj_tag(x_25) == 0) +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; size_t x_30; size_t x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_23, 1); +lean_inc(x_26); +lean_dec(x_23); +x_27 = lean_ctor_get(x_24, 1); +lean_inc(x_27); +lean_dec(x_24); +x_28 = lean_ctor_get(x_25, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_25, 1); +lean_inc(x_29); +lean_dec(x_25); +x_30 = 1; +x_31 = lean_usize_add(x_4, x_30); +x_32 = lean_array_uset(x_18, x_4, x_28); +x_4 = x_31; +x_5 = x_32; +x_9 = x_29; +x_10 = x_27; +x_11 = x_26; +goto _start; +} +else +{ +uint8_t x_34; +lean_dec(x_18); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_34 = !lean_is_exclusive(x_23); +if (x_34 == 0) +{ +lean_object* x_35; uint8_t x_36; +x_35 = lean_ctor_get(x_23, 0); +lean_dec(x_35); +x_36 = !lean_is_exclusive(x_24); +if (x_36 == 0) +{ +lean_object* x_37; uint8_t x_38; +x_37 = lean_ctor_get(x_24, 0); +lean_dec(x_37); +x_38 = !lean_is_exclusive(x_25); +if (x_38 == 0) +{ +return x_23; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_39 = lean_ctor_get(x_25, 0); +x_40 = lean_ctor_get(x_25, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_25); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_40); +lean_ctor_set(x_24, 0, x_41); +return x_23; +} +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_42 = lean_ctor_get(x_24, 1); +lean_inc(x_42); +lean_dec(x_24); +x_43 = lean_ctor_get(x_25, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_25, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_25)) { + lean_ctor_release(x_25, 0); + lean_ctor_release(x_25, 1); + x_45 = x_25; +} else { + lean_dec_ref(x_25); + x_45 = lean_box(0); +} +if (lean_is_scalar(x_45)) { + x_46 = lean_alloc_ctor(1, 2, 0); +} else { + x_46 = x_45; +} +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_44); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_42); +lean_ctor_set(x_23, 0, x_47); +return x_23; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_48 = lean_ctor_get(x_23, 1); +lean_inc(x_48); +lean_dec(x_23); +x_49 = lean_ctor_get(x_24, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_50 = x_24; +} else { + lean_dec_ref(x_24); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_25, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_25, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_25)) { + lean_ctor_release(x_25, 0); + lean_ctor_release(x_25, 1); + x_53 = x_25; +} else { + lean_dec_ref(x_25); + x_53 = lean_box(0); +} +if (lean_is_scalar(x_53)) { + x_54 = lean_alloc_ctor(1, 2, 0); +} else { + x_54 = x_53; +} +lean_ctor_set(x_54, 0, x_51); +lean_ctor_set(x_54, 1, x_52); +if (lean_is_scalar(x_50)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_50; +} +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_49); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_48); +return x_56; +} +} +} +else +{ +uint8_t x_57; +lean_dec(x_18); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_57 = !lean_is_exclusive(x_23); +if (x_57 == 0) +{ +return x_23; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_23, 0); +x_59 = lean_ctor_get(x_23, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_23); +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set(x_60, 1, x_59); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_61 = lean_ctor_get(x_2, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_61, 2); +lean_inc(x_63); +lean_dec(x_61); +x_64 = lean_ctor_get(x_63, 7); +lean_inc(x_64); +lean_dec(x_63); +x_65 = l_System_FilePath_join(x_62, x_64); +x_66 = lean_ctor_get(x_2, 1); +lean_inc(x_66); +x_67 = lean_ctor_get(x_66, 2); +lean_inc(x_67); +lean_dec(x_66); +x_68 = l_System_FilePath_join(x_65, x_67); +x_69 = l_Lake_Module_recParseImports___closed__1; +x_70 = l_Lean_modToFilePath(x_68, x_20, x_69); +lean_dec(x_68); +x_71 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_72 = lean_string_append(x_71, x_70); +lean_dec(x_70); +x_73 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___closed__1; +x_74 = lean_string_append(x_72, x_73); +x_75 = 3; +x_76 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set_uint8(x_76, sizeof(void*)*1, x_75); +x_77 = lean_array_push(x_9, x_76); +x_78 = lean_box(0); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_79 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1(x_16, x_78, x_6, x_7, x_8, x_77, x_10, x_11); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_80, 0); +lean_inc(x_81); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; size_t x_86; size_t x_87; lean_object* x_88; +x_82 = lean_ctor_get(x_79, 1); +lean_inc(x_82); +lean_dec(x_79); +x_83 = lean_ctor_get(x_80, 1); +lean_inc(x_83); +lean_dec(x_80); +x_84 = lean_ctor_get(x_81, 0); +lean_inc(x_84); +x_85 = lean_ctor_get(x_81, 1); +lean_inc(x_85); +lean_dec(x_81); +x_86 = 1; +x_87 = lean_usize_add(x_4, x_86); +x_88 = lean_array_uset(x_18, x_4, x_84); +x_4 = x_87; +x_5 = x_88; +x_9 = x_85; +x_10 = x_83; +x_11 = x_82; +goto _start; +} +else +{ +uint8_t x_90; +lean_dec(x_18); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_90 = !lean_is_exclusive(x_79); +if (x_90 == 0) +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_79, 0); +lean_dec(x_91); +x_92 = !lean_is_exclusive(x_80); +if (x_92 == 0) +{ +lean_object* x_93; uint8_t x_94; +x_93 = lean_ctor_get(x_80, 0); +lean_dec(x_93); +x_94 = !lean_is_exclusive(x_81); +if (x_94 == 0) +{ +return x_79; +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_95 = lean_ctor_get(x_81, 0); +x_96 = lean_ctor_get(x_81, 1); +lean_inc(x_96); +lean_inc(x_95); +lean_dec(x_81); +x_97 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_97, 0, x_95); +lean_ctor_set(x_97, 1, x_96); +lean_ctor_set(x_80, 0, x_97); +return x_79; +} +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_98 = lean_ctor_get(x_80, 1); +lean_inc(x_98); +lean_dec(x_80); +x_99 = lean_ctor_get(x_81, 0); +lean_inc(x_99); +x_100 = lean_ctor_get(x_81, 1); +lean_inc(x_100); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_101 = x_81; +} else { + lean_dec_ref(x_81); + x_101 = lean_box(0); +} +if (lean_is_scalar(x_101)) { + x_102 = lean_alloc_ctor(1, 2, 0); +} else { + x_102 = x_101; +} +lean_ctor_set(x_102, 0, x_99); +lean_ctor_set(x_102, 1, x_100); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_98); +lean_ctor_set(x_79, 0, x_103); +return x_79; +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_104 = lean_ctor_get(x_79, 1); +lean_inc(x_104); +lean_dec(x_79); +x_105 = lean_ctor_get(x_80, 1); +lean_inc(x_105); +if (lean_is_exclusive(x_80)) { + lean_ctor_release(x_80, 0); + lean_ctor_release(x_80, 1); + x_106 = x_80; +} else { + lean_dec_ref(x_80); + x_106 = lean_box(0); +} +x_107 = lean_ctor_get(x_81, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_81, 1); +lean_inc(x_108); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_109 = x_81; +} else { + lean_dec_ref(x_81); + x_109 = lean_box(0); +} +if (lean_is_scalar(x_109)) { + x_110 = lean_alloc_ctor(1, 2, 0); +} else { + x_110 = x_109; +} +lean_ctor_set(x_110, 0, x_107); +lean_ctor_set(x_110, 1, x_108); +if (lean_is_scalar(x_106)) { + x_111 = lean_alloc_ctor(0, 2, 0); +} else { + x_111 = x_106; +} +lean_ctor_set(x_111, 0, x_110); +lean_ctor_set(x_111, 1, x_105); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_104); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_dec(x_18); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_113 = !lean_is_exclusive(x_79); +if (x_113 == 0) +{ +return x_79; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_79, 0); +x_115 = lean_ctor_get(x_79, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_79); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +} +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("dynlib", 6); +return x_1; +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2(size_t x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = lean_usize_dec_lt(x_2, x_1); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_3); +lean_ctor_set(x_11, 1, x_7); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_14 = lean_array_uget(x_3, x_2); +x_15 = lean_unsigned_to_nat(0u); +x_16 = lean_array_uset(x_3, x_2, x_15); +x_17 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__2; +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_14); +lean_ctor_set(x_18, 1, x_17); +lean_inc(x_4); +lean_inc(x_6); +lean_inc(x_5); +x_19 = lean_apply_6(x_4, x_18, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; size_t x_26; size_t x_27; lean_object* x_28; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_21, 1); +lean_inc(x_25); +lean_dec(x_21); +x_26 = 1; +x_27 = lean_usize_add(x_2, x_26); +x_28 = lean_array_uset(x_16, x_2, x_24); +x_2 = x_27; +x_3 = x_28; +x_7 = x_25; +x_8 = x_23; +x_9 = x_22; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_30 = !lean_is_exclusive(x_19); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_19, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_20); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_20, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_21); +if (x_34 == 0) +{ +return x_19; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_21, 0); +x_36 = lean_ctor_get(x_21, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_21); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_20, 0, x_37); +return x_19; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_20, 1); +lean_inc(x_38); +lean_dec(x_20); +x_39 = lean_ctor_get(x_21, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_21, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_41 = x_21; +} else { + lean_dec_ref(x_21); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +lean_ctor_set(x_19, 0, x_43); +return x_19; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +lean_dec(x_19); +x_45 = lean_ctor_get(x_20, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_46 = x_20; +} else { + lean_dec_ref(x_20); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_21, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_21, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_49 = x_21; +} else { + lean_dec_ref(x_21); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +if (lean_is_scalar(x_46)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_46; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_45); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_53 = !lean_is_exclusive(x_19); +if (x_53 == 0) +{ +return x_19; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_19, 0); +x_55 = lean_ctor_get(x_19, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_19); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +} +} +LEAN_EXPORT uint8_t l_List_elem___at_Lake_Module_recBuildDeps___spec__5(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_4, 2); +x_7 = lean_ctor_get(x_6, 2); +x_8 = lean_ctor_get(x_1, 2); +x_9 = lean_ctor_get(x_8, 2); +x_10 = lean_name_eq(x_7, x_9); +if (x_10 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_12; +x_12 = 1; +return x_12; +} +} +} +} +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_Module_recBuildDeps___spec__4(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint64_t x_7; size_t x_8; lean_object* x_9; uint8_t x_10; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = lean_ctor_get(x_2, 2); +x_6 = lean_ctor_get(x_5, 2); +x_7 = l_Lean_Name_hash___override(x_6); +x_8 = lean_hashset_mk_idx(x_4, x_7); +x_9 = lean_array_uget(x_3, x_8); +x_10 = l_List_elem___at_Lake_Module_recBuildDeps___spec__5(x_2, x_9); +lean_dec(x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recBuildDeps___spec__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_3, 1); +x_7 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_5); +x_8 = lean_apply_1(x_1, x_5); +x_9 = lean_unbox_uint64(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_7, x_9); +x_11 = lean_array_uget(x_2, x_10); +lean_ctor_set(x_3, 1, x_11); +x_12 = lean_array_uset(x_2, x_10, x_3); +x_2 = x_12; +x_3 = x_6; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint64_t x_18; size_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_14 = lean_ctor_get(x_3, 0); +x_15 = lean_ctor_get(x_3, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_3); +x_16 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_14); +x_17 = lean_apply_1(x_1, x_14); +x_18 = lean_unbox_uint64(x_17); +lean_dec(x_17); +x_19 = lean_hashset_mk_idx(x_16, x_18); +x_20 = lean_array_uget(x_2, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_14); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_array_uset(x_2, x_19, x_21); +x_2 = x_22; +x_3 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Module_recBuildDeps___spec__9___at_Lake_Module_recBuildDeps___spec__10(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_array_get_size(x_1); +x_7 = lean_ctor_get(x_4, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 2); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lean_Name_hash___override(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_6, x_9); +x_11 = lean_array_uget(x_1, x_10); +lean_ctor_set(x_2, 1, x_11); +x_12 = lean_array_uset(x_1, x_10, x_2); +x_1 = x_12; +x_2 = x_5; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint64_t x_19; size_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_14 = lean_ctor_get(x_2, 0); +x_15 = lean_ctor_get(x_2, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_2); +x_16 = lean_array_get_size(x_1); +x_17 = lean_ctor_get(x_14, 2); +lean_inc(x_17); +x_18 = lean_ctor_get(x_17, 2); +lean_inc(x_18); +lean_dec(x_17); +x_19 = l_Lean_Name_hash___override(x_18); +lean_dec(x_18); +x_20 = lean_hashset_mk_idx(x_16, x_19); +x_21 = lean_array_uget(x_1, x_20); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_14); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_array_uset(x_1, x_20, x_22); +x_1 = x_23; +x_2 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_Module_recBuildDeps___spec__8(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_array_get_size(x_2); +x_5 = lean_nat_dec_lt(x_1, x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_6 = lean_array_fget(x_2, x_1); +x_7 = lean_box(0); +x_8 = lean_array_fset(x_2, x_1, x_7); +x_9 = l_List_foldl___at_Lake_Module_recBuildDeps___spec__9___at_Lake_Module_recBuildDeps___spec__10(x_3, x_6); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_8; +x_3 = x_9; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_Module_recBuildDeps___spec__7(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_nat_mul(x_3, x_4); +lean_dec(x_3); +x_6 = lean_box(0); +x_7 = lean_mk_array(x_5, x_6); +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_HashSetImp_moveEntries___at_Lake_Module_recBuildDeps___spec__8(x_8, x_2, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recBuildDeps___spec__11(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; +lean_dec(x_3); +x_4 = lean_box(0); +return x_4; +} +else +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_1); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_6 = lean_ctor_get(x_1, 0); +x_7 = lean_ctor_get(x_1, 1); +x_8 = lean_ctor_get(x_6, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 2); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_ctor_get(x_2, 2); +x_11 = lean_ctor_get(x_10, 2); +x_12 = lean_name_eq(x_9, x_11); +lean_dec(x_9); +if (x_12 == 0) +{ +lean_object* x_13; +x_13 = l_List_replace___at_Lake_Module_recBuildDeps___spec__11(x_7, x_2, x_3); +lean_ctor_set(x_1, 1, x_13); +return x_1; +} +else +{ +lean_dec(x_6); +lean_ctor_set(x_1, 0, x_3); +return x_1; +} +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_14 = lean_ctor_get(x_1, 0); +x_15 = lean_ctor_get(x_1, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_1); +x_16 = lean_ctor_get(x_14, 2); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 2); +lean_inc(x_17); +lean_dec(x_16); +x_18 = lean_ctor_get(x_2, 2); +x_19 = lean_ctor_get(x_18, 2); +x_20 = lean_name_eq(x_17, x_19); +lean_dec(x_17); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = l_List_replace___at_Lake_Module_recBuildDeps___spec__11(x_15, x_2, x_3); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_14); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +else +{ +lean_object* x_23; +lean_dec(x_14); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_3); +lean_ctor_set(x_23, 1, x_15); +return x_23; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_Module_recBuildDeps___spec__6(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_1); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; uint8_t x_12; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_array_get_size(x_5); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 2); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lean_Name_hash___override(x_8); +lean_dec(x_8); +lean_inc(x_6); +x_10 = lean_hashset_mk_idx(x_6, x_9); +x_11 = lean_array_uget(x_5, x_10); +x_12 = l_List_elem___at_Lake_Module_recBuildDeps___spec__5(x_2, x_11); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; +x_13 = lean_unsigned_to_nat(1u); +x_14 = lean_nat_add(x_4, x_13); +lean_dec(x_4); +x_15 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_15, 0, x_2); +lean_ctor_set(x_15, 1, x_11); +x_16 = lean_array_uset(x_5, x_10, x_15); +x_17 = lean_nat_dec_le(x_14, x_6); +lean_dec(x_6); +if (x_17 == 0) +{ +lean_object* x_18; +lean_free_object(x_1); +x_18 = l_Lean_HashSetImp_expand___at_Lake_Module_recBuildDeps___spec__7(x_14, x_16); +return x_18; +} +else +{ +lean_ctor_set(x_1, 1, x_16); +lean_ctor_set(x_1, 0, x_14); +return x_1; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +lean_dec(x_6); +x_19 = lean_box(0); +x_20 = lean_array_uset(x_5, x_10, x_19); +lean_inc(x_2); +x_21 = l_List_replace___at_Lake_Module_recBuildDeps___spec__11(x_11, x_2, x_2); +lean_dec(x_2); +x_22 = lean_array_uset(x_20, x_10, x_21); +lean_ctor_set(x_1, 1, x_22); +return x_1; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint64_t x_28; size_t x_29; lean_object* x_30; uint8_t x_31; +x_23 = lean_ctor_get(x_1, 0); +x_24 = lean_ctor_get(x_1, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_1); +x_25 = lean_array_get_size(x_24); +x_26 = lean_ctor_get(x_2, 2); +lean_inc(x_26); +x_27 = lean_ctor_get(x_26, 2); +lean_inc(x_27); +lean_dec(x_26); +x_28 = l_Lean_Name_hash___override(x_27); +lean_dec(x_27); +lean_inc(x_25); +x_29 = lean_hashset_mk_idx(x_25, x_28); +x_30 = lean_array_uget(x_24, x_29); +x_31 = l_List_elem___at_Lake_Module_recBuildDeps___spec__5(x_2, x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_32 = lean_unsigned_to_nat(1u); +x_33 = lean_nat_add(x_23, x_32); +lean_dec(x_23); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_2); +lean_ctor_set(x_34, 1, x_30); +x_35 = lean_array_uset(x_24, x_29, x_34); +x_36 = lean_nat_dec_le(x_33, x_25); +lean_dec(x_25); +if (x_36 == 0) +{ +lean_object* x_37; +x_37 = l_Lean_HashSetImp_expand___at_Lake_Module_recBuildDeps___spec__7(x_33, x_35); +return x_37; +} +else +{ +lean_object* x_38; +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_33); +lean_ctor_set(x_38, 1, x_35); +return x_38; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_25); +x_39 = lean_box(0); +x_40 = lean_array_uset(x_24, x_29, x_39); +lean_inc(x_2); +x_41 = l_List_replace___at_Lake_Module_recBuildDeps___spec__11(x_30, x_2, x_2); +lean_dec(x_2); +x_42 = lean_array_uset(x_40, x_29, x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_23); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instHashablePackage___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instBEqPackage___boxed), 2, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = l_Lean_HashSetImp_contains___at_Lake_Module_recBuildDeps___spec__4(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +lean_inc(x_2); +x_6 = lean_array_push(x_5, x_2); +x_7 = l_Lean_HashSetImp_insert___at_Lake_Module_recBuildDeps___spec__6(x_3, x_2); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +return x_8; +} +else +{ +lean_dec(x_3); +lean_dec(x_2); +return x_1; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__13(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; +x_6 = lean_array_uget(x_1, x_2); +x_7 = l_Lake_Dynlib_dir_x3f(x_6); +x_8 = 1; +x_9 = lean_usize_add(x_2, x_8); +if (lean_obj_tag(x_7) == 0) +{ +x_2 = x_9; +goto _start; +} +else +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_7, 0); +lean_inc(x_11); +lean_dec(x_7); +x_12 = lean_array_push(x_4, x_11); +x_2 = x_9; +x_4 = x_12; +goto _start; +} +} +else +{ +return x_4; +} +} +} +LEAN_EXPORT lean_object* l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = lean_nat_dec_lt(x_2, x_3); +if (x_4 == 0) +{ +lean_object* x_5; +x_5 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +return x_5; +} +else +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_array_get_size(x_1); +x_7 = lean_nat_dec_le(x_3, x_6); +lean_dec(x_6); +if (x_7 == 0) +{ +lean_object* x_8; +x_8 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +return x_8; +} +else +{ +size_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_9 = lean_usize_of_nat(x_2); +x_10 = lean_usize_of_nat(x_3); +x_11 = l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1; +x_12 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__13(x_1, x_9, x_10, x_11); +return x_12; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(size_t x_1, size_t x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = lean_usize_dec_lt(x_2, x_1); +if (x_4 == 0) +{ +return x_3; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; size_t x_9; size_t x_10; lean_object* x_11; +x_5 = lean_array_uget(x_3, x_2); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_uset(x_3, x_2, x_6); +x_8 = lean_ctor_get(x_5, 0); +lean_inc(x_8); +lean_dec(x_5); +x_9 = 1; +x_10 = lean_usize_add(x_2, x_9); +x_11 = lean_array_uset(x_7, x_2, x_8); +x_2 = x_10; +x_3 = x_11; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; size_t x_10; size_t x_11; +x_6 = lean_array_uget(x_1, x_2); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3(x_4, x_8); +x_10 = 1; +x_11 = lean_usize_add(x_2, x_10); +x_2 = x_11; +x_4 = x_9; +goto _start; +} +else +{ +return x_4; +} +} +} +static lean_object* _init_l_Lake_Module_recBuildDeps___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_recBuildDeps___lambda__1___closed__2() { +_start: +{ +uint32_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 0; +x_2 = l_Lake_Module_recBuildDeps___lambda__1___closed__1; +x_3 = lean_alloc_ctor(0, 1, 4); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint32(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_recBuildDeps___lambda__1___closed__3___boxed__const__1() { +_start: +{ +uint64_t x_1; lean_object* x_2; +x_1 = l_Lake_platformTrace; +x_2 = lean_box_uint64(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_recBuildDeps___lambda__1___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_recBuildDeps___lambda__1___closed__2; +x_2 = l_Lake_Module_recBuildDeps___lambda__1___closed__3___boxed__const__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, size_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; size_t x_23; lean_object* x_24; lean_object* x_25; size_t x_26; lean_object* x_27; lean_object* x_28; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +x_13 = l_Lake_BuildTrace_mix(x_1, x_2); +x_14 = l_Lake_BuildTrace_mix(x_3, x_13); +x_15 = lean_ctor_get(x_4, 1); +x_16 = lean_ctor_get(x_15, 0); +x_17 = lean_ctor_get(x_16, 8); +x_18 = lean_array_get_size(x_11); +x_19 = lean_unsigned_to_nat(0u); +x_20 = l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12(x_11, x_19, x_18); +x_21 = l_Array_append___rarg(x_5, x_20); +lean_dec(x_20); +x_22 = lean_array_to_list(lean_box(0), x_21); +x_23 = lean_usize_of_nat(x_18); +lean_dec(x_18); +x_24 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(x_23, x_6, x_11); +x_25 = lean_array_get_size(x_7); +x_26 = lean_usize_of_nat(x_25); +lean_dec(x_25); +x_27 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(x_26, x_6, x_7); +x_28 = l_Array_append___rarg(x_24, x_27); +lean_dec(x_27); +lean_ctor_set(x_9, 1, x_28); +lean_ctor_set(x_9, 0, x_22); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_8, 2); +x_30 = lean_ctor_get(x_29, 1); +x_31 = lean_ctor_get(x_30, 8); +if (lean_obj_tag(x_31) == 0) +{ +lean_object* x_32; lean_object* x_33; +x_32 = l_Lake_BuildTrace_mix(x_14, x_12); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_9); +lean_ctor_set(x_33, 1, x_32); +return x_33; +} +else +{ +lean_object* x_34; uint8_t x_35; +x_34 = lean_ctor_get(x_31, 0); +x_35 = lean_unbox(x_34); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = l_Lake_Module_recBuildDeps___lambda__1___closed__3; +x_37 = l_Lake_BuildTrace_mix(x_12, x_36); +x_38 = l_Lake_BuildTrace_mix(x_14, x_37); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_9); +lean_ctor_set(x_39, 1, x_38); +return x_39; +} +else +{ +lean_object* x_40; +lean_dec(x_12); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_9); +lean_ctor_set(x_40, 1, x_14); +return x_40; +} +} +} +else +{ +lean_object* x_41; uint8_t x_42; +x_41 = lean_ctor_get(x_17, 0); +x_42 = lean_unbox(x_41); +if (x_42 == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = l_Lake_Module_recBuildDeps___lambda__1___closed__3; +x_44 = l_Lake_BuildTrace_mix(x_12, x_43); +x_45 = l_Lake_BuildTrace_mix(x_14, x_44); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_9); +lean_ctor_set(x_46, 1, x_45); +return x_46; +} +else +{ +lean_object* x_47; +lean_dec(x_12); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_9); +lean_ctor_set(x_47, 1, x_14); +return x_47; +} +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; size_t x_60; lean_object* x_61; lean_object* x_62; size_t x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_48 = lean_ctor_get(x_9, 0); +x_49 = lean_ctor_get(x_9, 1); +lean_inc(x_49); +lean_inc(x_48); +lean_dec(x_9); +x_50 = l_Lake_BuildTrace_mix(x_1, x_2); +x_51 = l_Lake_BuildTrace_mix(x_3, x_50); +x_52 = lean_ctor_get(x_4, 1); +x_53 = lean_ctor_get(x_52, 0); +x_54 = lean_ctor_get(x_53, 8); +x_55 = lean_array_get_size(x_48); +x_56 = lean_unsigned_to_nat(0u); +x_57 = l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12(x_48, x_56, x_55); +x_58 = l_Array_append___rarg(x_5, x_57); +lean_dec(x_57); +x_59 = lean_array_to_list(lean_box(0), x_58); +x_60 = lean_usize_of_nat(x_55); +lean_dec(x_55); +x_61 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(x_60, x_6, x_48); +x_62 = lean_array_get_size(x_7); +x_63 = lean_usize_of_nat(x_62); +lean_dec(x_62); +x_64 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(x_63, x_6, x_7); +x_65 = l_Array_append___rarg(x_61, x_64); +lean_dec(x_64); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_59); +lean_ctor_set(x_66, 1, x_65); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_8, 2); +x_68 = lean_ctor_get(x_67, 1); +x_69 = lean_ctor_get(x_68, 8); +if (lean_obj_tag(x_69) == 0) +{ +lean_object* x_70; lean_object* x_71; +x_70 = l_Lake_BuildTrace_mix(x_51, x_49); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_66); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +else +{ +lean_object* x_72; uint8_t x_73; +x_72 = lean_ctor_get(x_69, 0); +x_73 = lean_unbox(x_72); +if (x_73 == 0) +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_74 = l_Lake_Module_recBuildDeps___lambda__1___closed__3; +x_75 = l_Lake_BuildTrace_mix(x_49, x_74); +x_76 = l_Lake_BuildTrace_mix(x_51, x_75); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_66); +lean_ctor_set(x_77, 1, x_76); +return x_77; +} +else +{ +lean_object* x_78; +lean_dec(x_49); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_66); +lean_ctor_set(x_78, 1, x_51); +return x_78; +} +} +} +else +{ +lean_object* x_79; uint8_t x_80; +x_79 = lean_ctor_get(x_54, 0); +x_80 = lean_unbox(x_79); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_81 = l_Lake_Module_recBuildDeps___lambda__1___closed__3; +x_82 = l_Lake_BuildTrace_mix(x_49, x_81); +x_83 = l_Lake_BuildTrace_mix(x_51, x_82); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_66); +lean_ctor_set(x_84, 1, x_83); +return x_84; +} +else +{ +lean_object* x_85; +lean_dec(x_49); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_66); +lean_ctor_set(x_85, 1, x_51); +return x_85; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 1); +x_5 = l_Lake_JobState_merge(x_1, x_4); +lean_ctor_set(x_2, 1, x_5); +return x_2; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +lean_inc(x_7); +lean_inc(x_6); +lean_dec(x_2); +x_8 = l_Lake_JobState_merge(x_1, x_7); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_6); +lean_ctor_set(x_9, 1, x_8); +return x_9; +} +} +else +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_2); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get(x_2, 1); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = lean_array_get_size(x_13); +lean_dec(x_13); +x_15 = lean_nat_add(x_14, x_11); +lean_dec(x_11); +lean_dec(x_14); +x_16 = l_Lake_JobState_merge(x_1, x_12); +lean_ctor_set(x_2, 1, x_16); +lean_ctor_set(x_2, 0, x_15); +return x_2; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_2, 0); +x_18 = lean_ctor_get(x_2, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_2); +x_19 = lean_ctor_get(x_1, 0); +lean_inc(x_19); +x_20 = lean_array_get_size(x_19); +lean_dec(x_19); +x_21 = lean_nat_add(x_20, x_17); +lean_dec(x_17); +lean_dec(x_20); +x_22 = l_Lake_JobState_merge(x_1, x_18); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, size_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = !lean_is_exclusive(x_10); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; +x_13 = lean_ctor_get(x_10, 0); +x_14 = lean_ctor_get(x_10, 1); +x_15 = lean_box_usize(x_5); +x_16 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__1___boxed), 9, 8); +lean_closure_set(x_16, 0, x_1); +lean_closure_set(x_16, 1, x_14); +lean_closure_set(x_16, 2, x_2); +lean_closure_set(x_16, 3, x_3); +lean_closure_set(x_16, 4, x_4); +lean_closure_set(x_16, 5, x_15); +lean_closure_set(x_16, 6, x_13); +lean_closure_set(x_16, 7, x_6); +x_17 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_17, 0, x_16); +x_18 = lean_ctor_get(x_7, 0); +lean_inc(x_18); +lean_dec(x_7); +x_19 = l_Task_Priority_default; +x_20 = 0; +x_21 = lean_task_map(x_17, x_18, x_19, x_20); +x_22 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_22, 0, x_11); +x_23 = 1; +x_24 = lean_task_map(x_22, x_21, x_19, x_23); +lean_ctor_set(x_10, 1, x_9); +lean_ctor_set(x_10, 0, x_24); +return x_10; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; +x_25 = lean_ctor_get(x_10, 0); +x_26 = lean_ctor_get(x_10, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_10); +x_27 = lean_box_usize(x_5); +x_28 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__1___boxed), 9, 8); +lean_closure_set(x_28, 0, x_1); +lean_closure_set(x_28, 1, x_26); +lean_closure_set(x_28, 2, x_2); +lean_closure_set(x_28, 3, x_3); +lean_closure_set(x_28, 4, x_4); +lean_closure_set(x_28, 5, x_27); +lean_closure_set(x_28, 6, x_25); +lean_closure_set(x_28, 7, x_6); +x_29 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_29, 0, x_28); +x_30 = lean_ctor_get(x_7, 0); +lean_inc(x_30); +lean_dec(x_7); +x_31 = l_Task_Priority_default; +x_32 = 0; +x_33 = lean_task_map(x_29, x_30, x_31, x_32); +x_34 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_34, 0, x_11); +x_35 = 1; +x_36 = lean_task_map(x_34, x_33, x_31, x_35); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_9); +return x_37; +} +} +else +{ +uint8_t x_38; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_38 = !lean_is_exclusive(x_8); +if (x_38 == 0) +{ +lean_object* x_39; lean_object* x_40; +x_39 = lean_task_pure(x_8); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_9); +return x_40; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_41 = lean_ctor_get(x_8, 0); +x_42 = lean_ctor_get(x_8, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_8); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +x_44 = lean_task_pure(x_43); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_9); +return x_45; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, size_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +lean_dec(x_1); +x_14 = lean_box_usize(x_5); +x_15 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__3___boxed), 9, 7); +lean_closure_set(x_15, 0, x_12); +lean_closure_set(x_15, 1, x_2); +lean_closure_set(x_15, 2, x_3); +lean_closure_set(x_15, 3, x_4); +lean_closure_set(x_15, 4, x_14); +lean_closure_set(x_15, 5, x_6); +lean_closure_set(x_15, 6, x_7); +x_16 = l_Task_Priority_default; +x_17 = 0; +x_18 = lean_io_bind_task(x_13, x_15, x_16, x_17, x_9); +if (lean_obj_tag(x_18) == 0) +{ +uint8_t x_19; +x_19 = !lean_is_exclusive(x_18); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; +x_20 = lean_ctor_get(x_18, 0); +x_21 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_21, 0, x_11); +x_22 = 1; +x_23 = lean_task_map(x_21, x_20, x_16, x_22); +lean_ctor_set(x_18, 0, x_23); +return x_18; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; +x_24 = lean_ctor_get(x_18, 0); +x_25 = lean_ctor_get(x_18, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_18); +x_26 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_26, 0, x_11); +x_27 = 1; +x_28 = lean_task_map(x_26, x_24, x_16, x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_25); +return x_29; +} +} +else +{ +uint8_t x_30; +lean_dec(x_11); +x_30 = !lean_is_exclusive(x_18); +if (x_30 == 0) +{ +return x_18; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_18, 0); +x_32 = lean_ctor_get(x_18, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_18); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +return x_33; +} +} +} +else +{ +uint8_t x_34; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_34 = !lean_is_exclusive(x_8); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_task_pure(x_8); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_9); +return x_36; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_37 = lean_ctor_get(x_8, 0); +x_38 = lean_ctor_get(x_8, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_8); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_task_pure(x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_9); +return x_41; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, size_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +lean_dec(x_1); +x_14 = lean_box_usize(x_5); +x_15 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__4___boxed), 9, 7); +lean_closure_set(x_15, 0, x_2); +lean_closure_set(x_15, 1, x_12); +lean_closure_set(x_15, 2, x_3); +lean_closure_set(x_15, 3, x_4); +lean_closure_set(x_15, 4, x_14); +lean_closure_set(x_15, 5, x_6); +lean_closure_set(x_15, 6, x_7); +x_16 = l_Task_Priority_default; +x_17 = 0; +x_18 = lean_io_bind_task(x_13, x_15, x_16, x_17, x_9); +if (lean_obj_tag(x_18) == 0) +{ +uint8_t x_19; +x_19 = !lean_is_exclusive(x_18); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; +x_20 = lean_ctor_get(x_18, 0); +x_21 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_21, 0, x_11); +x_22 = 1; +x_23 = lean_task_map(x_21, x_20, x_16, x_22); +lean_ctor_set(x_18, 0, x_23); +return x_18; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; +x_24 = lean_ctor_get(x_18, 0); +x_25 = lean_ctor_get(x_18, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_18); +x_26 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_26, 0, x_11); +x_27 = 1; +x_28 = lean_task_map(x_26, x_24, x_16, x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_25); +return x_29; +} +} +else +{ +uint8_t x_30; +lean_dec(x_11); +x_30 = !lean_is_exclusive(x_18); +if (x_30 == 0) +{ +return x_18; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_18, 0); +x_32 = lean_ctor_get(x_18, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_18); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +return x_33; +} +} +} +else +{ +uint8_t x_34; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_34 = !lean_is_exclusive(x_8); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_task_pure(x_8); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_9); +return x_36; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_37 = lean_ctor_get(x_8, 0); +x_38 = lean_ctor_get(x_8, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_8); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_task_pure(x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_9); +return x_41; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__6(size_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; size_t x_13; lean_object* x_14; +x_12 = lean_array_get_size(x_5); +x_13 = lean_usize_of_nat(x_12); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +x_14 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2(x_13, x_1, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_16, 1); +lean_inc(x_20); +lean_dec(x_16); +x_21 = lean_unsigned_to_nat(0u); +x_22 = lean_nat_dec_lt(x_21, x_12); +x_23 = lean_ctor_get(x_2, 0); +lean_inc(x_23); +if (x_22 == 0) +{ +lean_object* x_149; +lean_dec(x_12); +lean_dec(x_5); +x_149 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_24 = x_149; +goto block_148; +} +else +{ +uint8_t x_150; +x_150 = lean_nat_dec_le(x_12, x_12); +lean_dec(x_12); +if (x_150 == 0) +{ +lean_object* x_151; +lean_dec(x_5); +x_151 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_24 = x_151; +goto block_148; +} +else +{ +lean_object* x_152; lean_object* x_153; +x_152 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_153 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15(x_5, x_1, x_13, x_152); +lean_dec(x_5); +x_24 = x_153; +goto block_148; +} +} +block_148: +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_23); +x_25 = l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3(x_24, x_23); +x_26 = lean_ctor_get(x_25, 1); +lean_inc(x_26); +lean_dec(x_25); +x_27 = l_Lake_recBuildExternDynlibs(x_26, x_6, x_7, x_8, x_20, x_18, x_17); +lean_dec(x_26); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_27, 1); +lean_inc(x_31); +lean_dec(x_27); +x_32 = lean_ctor_get(x_28, 1); +lean_inc(x_32); +lean_dec(x_28); +x_33 = !lean_is_exclusive(x_29); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_34 = lean_ctor_get(x_29, 1); +x_35 = lean_ctor_get(x_29, 0); +lean_dec(x_35); +x_36 = !lean_is_exclusive(x_30); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; +x_37 = lean_ctor_get(x_30, 0); +x_38 = lean_ctor_get(x_30, 1); +x_39 = l_Lake_BuildJob_collectArray___rarg(x_37); +lean_dec(x_37); +x_40 = l_Lake_BuildJob_collectArray___rarg(x_19); +lean_dec(x_19); +x_41 = !lean_is_exclusive(x_3); +if (x_41 == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; lean_object* x_48; +x_42 = lean_ctor_get(x_3, 0); +x_43 = lean_ctor_get(x_3, 1); +x_44 = lean_box_usize(x_1); +x_45 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__5___boxed), 9, 7); +lean_closure_set(x_45, 0, x_4); +lean_closure_set(x_45, 1, x_40); +lean_closure_set(x_45, 2, x_2); +lean_closure_set(x_45, 3, x_38); +lean_closure_set(x_45, 4, x_44); +lean_closure_set(x_45, 5, x_23); +lean_closure_set(x_45, 6, x_39); +x_46 = l_Task_Priority_default; +x_47 = 0; +x_48 = lean_io_bind_task(x_42, x_45, x_46, x_47, x_31); +if (lean_obj_tag(x_48) == 0) +{ +uint8_t x_49; +x_49 = !lean_is_exclusive(x_48); +if (x_49 == 0) +{ +lean_object* x_50; +x_50 = lean_ctor_get(x_48, 0); +lean_ctor_set(x_3, 0, x_50); +lean_ctor_set(x_29, 0, x_3); +lean_ctor_set(x_30, 1, x_32); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_48, 0, x_30); +return x_48; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_48, 0); +x_52 = lean_ctor_get(x_48, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_48); +lean_ctor_set(x_3, 0, x_51); +lean_ctor_set(x_29, 0, x_3); +lean_ctor_set(x_30, 1, x_32); +lean_ctor_set(x_30, 0, x_29); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_30); +lean_ctor_set(x_53, 1, x_52); +return x_53; +} +} +else +{ +uint8_t x_54; +lean_free_object(x_3); +lean_dec(x_43); +lean_free_object(x_30); +lean_free_object(x_29); +lean_dec(x_34); +lean_dec(x_32); +x_54 = !lean_is_exclusive(x_48); +if (x_54 == 0) +{ +return x_48; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_48, 0); +x_56 = lean_ctor_get(x_48, 1); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_48); +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set(x_57, 1, x_56); +return x_57; +} +} +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; +x_58 = lean_ctor_get(x_3, 0); +x_59 = lean_ctor_get(x_3, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_3); +x_60 = lean_box_usize(x_1); +x_61 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__5___boxed), 9, 7); +lean_closure_set(x_61, 0, x_4); +lean_closure_set(x_61, 1, x_40); +lean_closure_set(x_61, 2, x_2); +lean_closure_set(x_61, 3, x_38); +lean_closure_set(x_61, 4, x_60); +lean_closure_set(x_61, 5, x_23); +lean_closure_set(x_61, 6, x_39); +x_62 = l_Task_Priority_default; +x_63 = 0; +x_64 = lean_io_bind_task(x_58, x_61, x_62, x_63, x_31); +if (lean_obj_tag(x_64) == 0) +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_65 = lean_ctor_get(x_64, 0); +lean_inc(x_65); +x_66 = lean_ctor_get(x_64, 1); +lean_inc(x_66); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_67 = x_64; +} else { + lean_dec_ref(x_64); + x_67 = lean_box(0); +} +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_65); +lean_ctor_set(x_68, 1, x_59); +lean_ctor_set(x_29, 0, x_68); +lean_ctor_set(x_30, 1, x_32); +lean_ctor_set(x_30, 0, x_29); +if (lean_is_scalar(x_67)) { + x_69 = lean_alloc_ctor(0, 2, 0); +} else { + x_69 = x_67; +} +lean_ctor_set(x_69, 0, x_30); +lean_ctor_set(x_69, 1, x_66); +return x_69; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +lean_dec(x_59); +lean_free_object(x_30); +lean_free_object(x_29); +lean_dec(x_34); +lean_dec(x_32); +x_70 = lean_ctor_get(x_64, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_64, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_72 = x_64; +} else { + lean_dec_ref(x_64); + x_72 = lean_box(0); +} +if (lean_is_scalar(x_72)) { + x_73 = lean_alloc_ctor(1, 2, 0); +} else { + x_73 = x_72; +} +lean_ctor_set(x_73, 0, x_70); +lean_ctor_set(x_73, 1, x_71); +return x_73; +} +} +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; uint8_t x_84; lean_object* x_85; +x_74 = lean_ctor_get(x_30, 0); +x_75 = lean_ctor_get(x_30, 1); +lean_inc(x_75); +lean_inc(x_74); +lean_dec(x_30); +x_76 = l_Lake_BuildJob_collectArray___rarg(x_74); +lean_dec(x_74); +x_77 = l_Lake_BuildJob_collectArray___rarg(x_19); +lean_dec(x_19); +x_78 = lean_ctor_get(x_3, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_3, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + x_80 = x_3; +} else { + lean_dec_ref(x_3); + x_80 = lean_box(0); +} +x_81 = lean_box_usize(x_1); +x_82 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__5___boxed), 9, 7); +lean_closure_set(x_82, 0, x_4); +lean_closure_set(x_82, 1, x_77); +lean_closure_set(x_82, 2, x_2); +lean_closure_set(x_82, 3, x_75); +lean_closure_set(x_82, 4, x_81); +lean_closure_set(x_82, 5, x_23); +lean_closure_set(x_82, 6, x_76); +x_83 = l_Task_Priority_default; +x_84 = 0; +x_85 = lean_io_bind_task(x_78, x_82, x_83, x_84, x_31); +if (lean_obj_tag(x_85) == 0) +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_86 = lean_ctor_get(x_85, 0); +lean_inc(x_86); +x_87 = lean_ctor_get(x_85, 1); +lean_inc(x_87); +if (lean_is_exclusive(x_85)) { + lean_ctor_release(x_85, 0); + lean_ctor_release(x_85, 1); + x_88 = x_85; +} else { + lean_dec_ref(x_85); + x_88 = lean_box(0); +} +if (lean_is_scalar(x_80)) { + x_89 = lean_alloc_ctor(0, 2, 0); +} else { + x_89 = x_80; +} +lean_ctor_set(x_89, 0, x_86); +lean_ctor_set(x_89, 1, x_79); +lean_ctor_set(x_29, 0, x_89); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_29); +lean_ctor_set(x_90, 1, x_32); +if (lean_is_scalar(x_88)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_88; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_87); +return x_91; +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_80); +lean_dec(x_79); +lean_free_object(x_29); +lean_dec(x_34); +lean_dec(x_32); +x_92 = lean_ctor_get(x_85, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_85, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_85)) { + lean_ctor_release(x_85, 0); + lean_ctor_release(x_85, 1); + x_94 = x_85; +} else { + lean_dec_ref(x_85); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +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; uint8_t x_108; lean_object* x_109; +x_96 = lean_ctor_get(x_29, 1); +lean_inc(x_96); +lean_dec(x_29); +x_97 = lean_ctor_get(x_30, 0); +lean_inc(x_97); +x_98 = lean_ctor_get(x_30, 1); +lean_inc(x_98); +if (lean_is_exclusive(x_30)) { + lean_ctor_release(x_30, 0); + lean_ctor_release(x_30, 1); + x_99 = x_30; +} else { + lean_dec_ref(x_30); + x_99 = lean_box(0); +} +x_100 = l_Lake_BuildJob_collectArray___rarg(x_97); +lean_dec(x_97); +x_101 = l_Lake_BuildJob_collectArray___rarg(x_19); +lean_dec(x_19); +x_102 = lean_ctor_get(x_3, 0); +lean_inc(x_102); +x_103 = lean_ctor_get(x_3, 1); +lean_inc(x_103); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + x_104 = x_3; +} else { + lean_dec_ref(x_3); + x_104 = lean_box(0); +} +x_105 = lean_box_usize(x_1); +x_106 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__5___boxed), 9, 7); +lean_closure_set(x_106, 0, x_4); +lean_closure_set(x_106, 1, x_101); +lean_closure_set(x_106, 2, x_2); +lean_closure_set(x_106, 3, x_98); +lean_closure_set(x_106, 4, x_105); +lean_closure_set(x_106, 5, x_23); +lean_closure_set(x_106, 6, x_100); +x_107 = l_Task_Priority_default; +x_108 = 0; +x_109 = lean_io_bind_task(x_102, x_106, x_107, x_108, x_31); +if (lean_obj_tag(x_109) == 0) +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_110 = lean_ctor_get(x_109, 0); +lean_inc(x_110); +x_111 = lean_ctor_get(x_109, 1); +lean_inc(x_111); +if (lean_is_exclusive(x_109)) { + lean_ctor_release(x_109, 0); + lean_ctor_release(x_109, 1); + x_112 = x_109; +} else { + lean_dec_ref(x_109); + x_112 = lean_box(0); +} +if (lean_is_scalar(x_104)) { + x_113 = lean_alloc_ctor(0, 2, 0); +} else { + x_113 = x_104; +} +lean_ctor_set(x_113, 0, x_110); +lean_ctor_set(x_113, 1, x_103); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_114, 1, x_96); +if (lean_is_scalar(x_99)) { + x_115 = lean_alloc_ctor(0, 2, 0); +} else { + x_115 = x_99; +} +lean_ctor_set(x_115, 0, x_114); +lean_ctor_set(x_115, 1, x_32); +if (lean_is_scalar(x_112)) { + x_116 = lean_alloc_ctor(0, 2, 0); +} else { + x_116 = x_112; +} +lean_ctor_set(x_116, 0, x_115); +lean_ctor_set(x_116, 1, x_111); +return x_116; +} +else +{ +lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; +lean_dec(x_104); +lean_dec(x_103); +lean_dec(x_99); +lean_dec(x_96); +lean_dec(x_32); +x_117 = lean_ctor_get(x_109, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_109, 1); +lean_inc(x_118); +if (lean_is_exclusive(x_109)) { + lean_ctor_release(x_109, 0); + lean_ctor_release(x_109, 1); + x_119 = x_109; +} else { + lean_dec_ref(x_109); + x_119 = lean_box(0); +} +if (lean_is_scalar(x_119)) { + x_120 = lean_alloc_ctor(1, 2, 0); +} else { + x_120 = x_119; +} +lean_ctor_set(x_120, 0, x_117); +lean_ctor_set(x_120, 1, x_118); +return x_120; +} +} +} +else +{ +uint8_t x_121; +lean_dec(x_23); +lean_dec(x_19); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_121 = !lean_is_exclusive(x_27); +if (x_121 == 0) +{ +lean_object* x_122; uint8_t x_123; +x_122 = lean_ctor_get(x_27, 0); +lean_dec(x_122); +x_123 = !lean_is_exclusive(x_28); +if (x_123 == 0) +{ +lean_object* x_124; uint8_t x_125; +x_124 = lean_ctor_get(x_28, 0); +lean_dec(x_124); +x_125 = !lean_is_exclusive(x_29); +if (x_125 == 0) +{ +return x_27; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_29, 0); +x_127 = lean_ctor_get(x_29, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_29); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +lean_ctor_set(x_28, 0, x_128); +return x_27; +} +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_129 = lean_ctor_get(x_28, 1); +lean_inc(x_129); +lean_dec(x_28); +x_130 = lean_ctor_get(x_29, 0); +lean_inc(x_130); +x_131 = lean_ctor_get(x_29, 1); +lean_inc(x_131); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_132 = x_29; +} else { + lean_dec_ref(x_29); + x_132 = lean_box(0); +} +if (lean_is_scalar(x_132)) { + x_133 = lean_alloc_ctor(1, 2, 0); +} else { + x_133 = x_132; +} +lean_ctor_set(x_133, 0, x_130); +lean_ctor_set(x_133, 1, x_131); +x_134 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_134, 0, x_133); +lean_ctor_set(x_134, 1, x_129); +lean_ctor_set(x_27, 0, x_134); +return x_27; +} +} +else +{ +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_135 = lean_ctor_get(x_27, 1); +lean_inc(x_135); +lean_dec(x_27); +x_136 = lean_ctor_get(x_28, 1); +lean_inc(x_136); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_137 = x_28; +} else { + lean_dec_ref(x_28); + x_137 = lean_box(0); +} +x_138 = lean_ctor_get(x_29, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_29, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_140 = x_29; +} else { + lean_dec_ref(x_29); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +if (lean_is_scalar(x_137)) { + x_142 = lean_alloc_ctor(0, 2, 0); +} else { + x_142 = x_137; +} +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_136); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_142); +lean_ctor_set(x_143, 1, x_135); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_dec(x_23); +lean_dec(x_19); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_144 = !lean_is_exclusive(x_27); +if (x_144 == 0) +{ +return x_27; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_27, 0); +x_146 = lean_ctor_get(x_27, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_27); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +} +else +{ +uint8_t x_154; +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_154 = !lean_is_exclusive(x_14); +if (x_154 == 0) +{ +lean_object* x_155; uint8_t x_156; +x_155 = lean_ctor_get(x_14, 0); +lean_dec(x_155); +x_156 = !lean_is_exclusive(x_15); +if (x_156 == 0) +{ +lean_object* x_157; uint8_t x_158; +x_157 = lean_ctor_get(x_15, 0); +lean_dec(x_157); +x_158 = !lean_is_exclusive(x_16); +if (x_158 == 0) +{ +return x_14; +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; +x_159 = lean_ctor_get(x_16, 0); +x_160 = lean_ctor_get(x_16, 1); +lean_inc(x_160); +lean_inc(x_159); +lean_dec(x_16); +x_161 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_161, 0, x_159); +lean_ctor_set(x_161, 1, x_160); +lean_ctor_set(x_15, 0, x_161); +return x_14; +} +} +else +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +x_162 = lean_ctor_get(x_15, 1); +lean_inc(x_162); +lean_dec(x_15); +x_163 = lean_ctor_get(x_16, 0); +lean_inc(x_163); +x_164 = lean_ctor_get(x_16, 1); +lean_inc(x_164); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_165 = x_16; +} else { + lean_dec_ref(x_16); + x_165 = lean_box(0); +} +if (lean_is_scalar(x_165)) { + x_166 = lean_alloc_ctor(1, 2, 0); +} else { + x_166 = x_165; +} +lean_ctor_set(x_166, 0, x_163); +lean_ctor_set(x_166, 1, x_164); +x_167 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_167, 0, x_166); +lean_ctor_set(x_167, 1, x_162); +lean_ctor_set(x_14, 0, x_167); +return x_14; +} +} +else +{ +lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; +x_168 = lean_ctor_get(x_14, 1); +lean_inc(x_168); +lean_dec(x_14); +x_169 = lean_ctor_get(x_15, 1); +lean_inc(x_169); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_170 = x_15; +} else { + lean_dec_ref(x_15); + x_170 = lean_box(0); +} +x_171 = lean_ctor_get(x_16, 0); +lean_inc(x_171); +x_172 = lean_ctor_get(x_16, 1); +lean_inc(x_172); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_173 = x_16; +} else { + lean_dec_ref(x_16); + x_173 = lean_box(0); +} +if (lean_is_scalar(x_173)) { + x_174 = lean_alloc_ctor(1, 2, 0); +} else { + x_174 = x_173; +} +lean_ctor_set(x_174, 0, x_171); +lean_ctor_set(x_174, 1, x_172); +if (lean_is_scalar(x_170)) { + x_175 = lean_alloc_ctor(0, 2, 0); +} else { + x_175 = x_170; +} +lean_ctor_set(x_175, 0, x_174); +lean_ctor_set(x_175, 1, x_169); +x_176 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_176, 0, x_175); +lean_ctor_set(x_176, 1, x_168); +return x_176; +} +} +} +else +{ +uint8_t x_177; +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_177 = !lean_is_exclusive(x_14); +if (x_177 == 0) +{ +return x_14; +} +else +{ +lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_178 = lean_ctor_get(x_14, 0); +x_179 = lean_ctor_get(x_14, 1); +lean_inc(x_179); +lean_inc(x_178); +lean_dec(x_14); +x_180 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_180, 0, x_178); +lean_ctor_set(x_180, 1, x_179); +return x_180; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__7(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; size_t x_12; size_t x_13; lean_object* x_14; +x_11 = lean_array_get_size(x_4); +x_12 = lean_usize_of_nat(x_11); +lean_dec(x_11); +x_13 = 0; +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_2); +lean_inc(x_1); +x_14 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1(x_1, x_2, x_12, x_13, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_18 = x_14; +} else { + lean_dec_ref(x_14); + x_18 = lean_box(0); +} +x_19 = lean_ctor_get(x_15, 1); +lean_inc(x_19); +lean_dec(x_15); +x_20 = lean_ctor_get(x_16, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_16, 1); +lean_inc(x_21); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_22 = x_16; +} else { + lean_dec_ref(x_16); + x_22 = lean_box(0); +} +x_23 = l_Lake_BuildJob_mixArray___rarg(x_20); +lean_dec(x_20); +x_97 = l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2; +x_98 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_98, 0, x_1); +lean_ctor_set(x_98, 1, x_97); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_99 = lean_apply_6(x_5, x_98, x_6, x_7, x_21, x_19, x_17); +if (lean_obj_tag(x_99) == 0) +{ +lean_object* x_100; lean_object* x_101; +x_100 = lean_ctor_get(x_99, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_100, 0); +lean_inc(x_101); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; uint8_t x_103; +x_102 = lean_ctor_get(x_99, 1); +lean_inc(x_102); +lean_dec(x_99); +x_103 = !lean_is_exclusive(x_100); +if (x_103 == 0) +{ +lean_object* x_104; uint8_t x_105; +x_104 = lean_ctor_get(x_100, 0); +lean_dec(x_104); +x_105 = !lean_is_exclusive(x_101); +if (x_105 == 0) +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; +x_106 = lean_ctor_get(x_101, 0); +x_107 = lean_box(0); +x_108 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_108, 0, x_106); +lean_ctor_set(x_108, 1, x_107); +lean_ctor_set(x_101, 0, x_108); +x_24 = x_100; +x_25 = x_102; +goto block_96; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_109 = lean_ctor_get(x_101, 0); +x_110 = lean_ctor_get(x_101, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_101); +x_111 = lean_box(0); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_111); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_110); +lean_ctor_set(x_100, 0, x_113); +x_24 = x_100; +x_25 = x_102; +goto block_96; +} +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; +x_114 = lean_ctor_get(x_100, 1); +lean_inc(x_114); +lean_dec(x_100); +x_115 = lean_ctor_get(x_101, 0); +lean_inc(x_115); +x_116 = lean_ctor_get(x_101, 1); +lean_inc(x_116); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_117 = x_101; +} else { + lean_dec_ref(x_101); + x_117 = lean_box(0); +} +x_118 = lean_box(0); +x_119 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_119, 0, x_115); +lean_ctor_set(x_119, 1, x_118); +if (lean_is_scalar(x_117)) { + x_120 = lean_alloc_ctor(0, 2, 0); +} else { + x_120 = x_117; +} +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_116); +x_121 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_121, 0, x_120); +lean_ctor_set(x_121, 1, x_114); +x_24 = x_121; +x_25 = x_102; +goto block_96; +} +} +else +{ +lean_object* x_122; uint8_t x_123; +x_122 = lean_ctor_get(x_99, 1); +lean_inc(x_122); +lean_dec(x_99); +x_123 = !lean_is_exclusive(x_100); +if (x_123 == 0) +{ +lean_object* x_124; uint8_t x_125; +x_124 = lean_ctor_get(x_100, 0); +lean_dec(x_124); +x_125 = !lean_is_exclusive(x_101); +if (x_125 == 0) +{ +x_24 = x_100; +x_25 = x_122; +goto block_96; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_101, 0); +x_127 = lean_ctor_get(x_101, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_101); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +lean_ctor_set(x_100, 0, x_128); +x_24 = x_100; +x_25 = x_122; +goto block_96; +} +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_129 = lean_ctor_get(x_100, 1); +lean_inc(x_129); +lean_dec(x_100); +x_130 = lean_ctor_get(x_101, 0); +lean_inc(x_130); +x_131 = lean_ctor_get(x_101, 1); +lean_inc(x_131); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_132 = x_101; +} else { + lean_dec_ref(x_101); + x_132 = lean_box(0); +} +if (lean_is_scalar(x_132)) { + x_133 = lean_alloc_ctor(1, 2, 0); +} else { + x_133 = x_132; +} +lean_ctor_set(x_133, 0, x_130); +lean_ctor_set(x_133, 1, x_131); +x_134 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_134, 0, x_133); +lean_ctor_set(x_134, 1, x_129); +x_24 = x_134; +x_25 = x_122; +goto block_96; +} +} +} +else +{ +uint8_t x_135; +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_18); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +x_135 = !lean_is_exclusive(x_99); +if (x_135 == 0) +{ +return x_99; +} +else +{ +lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_136 = lean_ctor_get(x_99, 0); +x_137 = lean_ctor_get(x_99, 1); +lean_inc(x_137); +lean_inc(x_136); +lean_dec(x_99); +x_138 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_138, 0, x_136); +lean_ctor_set(x_138, 1, x_137); +return x_138; +} +} +block_96: +{ +lean_object* x_26; +x_26 = lean_ctor_get(x_24, 0); +lean_inc(x_26); +if (lean_obj_tag(x_26) == 0) +{ +lean_object* x_27; +lean_dec(x_22); +x_27 = lean_ctor_get(x_26, 0); +lean_inc(x_27); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +lean_dec(x_18); +x_28 = lean_ctor_get(x_24, 1); +lean_inc(x_28); +lean_dec(x_24); +x_29 = lean_ctor_get(x_26, 1); +lean_inc(x_29); +lean_dec(x_26); +x_30 = lean_ctor_get(x_27, 0); +lean_inc(x_30); +lean_dec(x_27); +x_31 = l_Lake_Module_recBuildDeps___lambda__6(x_13, x_2, x_3, x_23, x_30, x_5, x_6, x_7, x_29, x_28, x_25); +return x_31; +} +else +{ +uint8_t x_32; +lean_dec(x_23); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +x_32 = !lean_is_exclusive(x_24); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_24, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_26); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_26, 0); +lean_dec(x_35); +x_36 = lean_ctor_get(x_27, 0); +lean_inc(x_36); +lean_dec(x_27); +lean_ctor_set(x_26, 0, x_36); +if (lean_is_scalar(x_18)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_18; +} +lean_ctor_set(x_37, 0, x_24); +lean_ctor_set(x_37, 1, x_25); +return x_37; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_26, 1); +lean_inc(x_38); +lean_dec(x_26); +x_39 = lean_ctor_get(x_27, 0); +lean_inc(x_39); +lean_dec(x_27); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_38); +lean_ctor_set(x_24, 0, x_40); +if (lean_is_scalar(x_18)) { + x_41 = lean_alloc_ctor(0, 2, 0); +} else { + x_41 = x_18; +} +lean_ctor_set(x_41, 0, x_24); +lean_ctor_set(x_41, 1, x_25); +return x_41; +} +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_42 = lean_ctor_get(x_24, 1); +lean_inc(x_42); +lean_dec(x_24); +x_43 = lean_ctor_get(x_26, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_26)) { + lean_ctor_release(x_26, 0); + lean_ctor_release(x_26, 1); + x_44 = x_26; +} else { + lean_dec_ref(x_26); + x_44 = lean_box(0); +} +x_45 = lean_ctor_get(x_27, 0); +lean_inc(x_45); +lean_dec(x_27); +if (lean_is_scalar(x_44)) { + x_46 = lean_alloc_ctor(0, 2, 0); +} else { + x_46 = x_44; +} +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_43); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_42); +if (lean_is_scalar(x_18)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_18; +} +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_25); +return x_48; +} +} +} +else +{ +uint8_t x_49; +lean_dec(x_23); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +x_49 = !lean_is_exclusive(x_24); +if (x_49 == 0) +{ +lean_object* x_50; uint8_t x_51; +x_50 = lean_ctor_get(x_24, 0); +lean_dec(x_50); +x_51 = !lean_is_exclusive(x_26); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_52 = lean_ctor_get(x_26, 0); +x_53 = lean_ctor_get(x_26, 1); +x_54 = lean_array_get_size(x_53); +lean_inc(x_52); +x_55 = l_Array_extract___rarg(x_53, x_52, x_54); +lean_dec(x_54); +x_56 = l_Array_shrink___rarg(x_53, x_52); +lean_dec(x_52); +x_57 = 0; +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_55); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_57); +x_59 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_26, 1, x_58); +lean_ctor_set(x_26, 0, x_59); +x_60 = lean_task_pure(x_26); +x_61 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +if (lean_is_scalar(x_22)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_22; +} +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_56); +lean_ctor_set(x_24, 0, x_63); +if (lean_is_scalar(x_18)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_18; +} +lean_ctor_set(x_64, 0, x_24); +lean_ctor_set(x_64, 1, x_25); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_65 = lean_ctor_get(x_26, 0); +x_66 = lean_ctor_get(x_26, 1); +lean_inc(x_66); +lean_inc(x_65); +lean_dec(x_26); +x_67 = lean_array_get_size(x_66); +lean_inc(x_65); +x_68 = l_Array_extract___rarg(x_66, x_65, x_67); +lean_dec(x_67); +x_69 = l_Array_shrink___rarg(x_66, x_65); +lean_dec(x_65); +x_70 = 0; +x_71 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set_uint8(x_71, sizeof(void*)*1, x_70); +x_72 = lean_unsigned_to_nat(0u); +x_73 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_71); +x_74 = lean_task_pure(x_73); +x_75 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +if (lean_is_scalar(x_22)) { + x_77 = lean_alloc_ctor(0, 2, 0); +} else { + x_77 = x_22; +} +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_69); +lean_ctor_set(x_24, 0, x_77); +if (lean_is_scalar(x_18)) { + x_78 = lean_alloc_ctor(0, 2, 0); +} else { + x_78 = x_18; +} +lean_ctor_set(x_78, 0, x_24); +lean_ctor_set(x_78, 1, x_25); +return x_78; +} +} +else +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t 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_79 = lean_ctor_get(x_24, 1); +lean_inc(x_79); +lean_dec(x_24); +x_80 = lean_ctor_get(x_26, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_26, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_26)) { + lean_ctor_release(x_26, 0); + lean_ctor_release(x_26, 1); + x_82 = x_26; +} else { + lean_dec_ref(x_26); + x_82 = lean_box(0); +} +x_83 = lean_array_get_size(x_81); +lean_inc(x_80); +x_84 = l_Array_extract___rarg(x_81, x_80, x_83); +lean_dec(x_83); +x_85 = l_Array_shrink___rarg(x_81, x_80); +lean_dec(x_80); +x_86 = 0; +x_87 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_87, 0, x_84); +lean_ctor_set_uint8(x_87, sizeof(void*)*1, x_86); +x_88 = lean_unsigned_to_nat(0u); +if (lean_is_scalar(x_82)) { + x_89 = lean_alloc_ctor(1, 2, 0); +} else { + x_89 = x_82; +} +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_87); +x_90 = lean_task_pure(x_89); +x_91 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set(x_92, 1, x_91); +if (lean_is_scalar(x_22)) { + x_93 = lean_alloc_ctor(0, 2, 0); +} else { + x_93 = x_22; +} +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_85); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_79); +if (lean_is_scalar(x_18)) { + x_95 = lean_alloc_ctor(0, 2, 0); +} else { + x_95 = x_18; +} +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_25); +return x_95; +} +} +} +} +else +{ +uint8_t x_139; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_139 = !lean_is_exclusive(x_14); +if (x_139 == 0) +{ +lean_object* x_140; uint8_t x_141; +x_140 = lean_ctor_get(x_14, 0); +lean_dec(x_140); +x_141 = !lean_is_exclusive(x_15); +if (x_141 == 0) +{ +lean_object* x_142; uint8_t x_143; +x_142 = lean_ctor_get(x_15, 0); +lean_dec(x_142); +x_143 = !lean_is_exclusive(x_16); +if (x_143 == 0) +{ +return x_14; +} +else +{ +lean_object* x_144; lean_object* x_145; lean_object* x_146; +x_144 = lean_ctor_get(x_16, 0); +x_145 = lean_ctor_get(x_16, 1); +lean_inc(x_145); +lean_inc(x_144); +lean_dec(x_16); +x_146 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_146, 0, x_144); +lean_ctor_set(x_146, 1, x_145); +lean_ctor_set(x_15, 0, x_146); +return x_14; +} +} +else +{ +lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_147 = lean_ctor_get(x_15, 1); +lean_inc(x_147); +lean_dec(x_15); +x_148 = lean_ctor_get(x_16, 0); +lean_inc(x_148); +x_149 = lean_ctor_get(x_16, 1); +lean_inc(x_149); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_150 = x_16; +} else { + lean_dec_ref(x_16); + x_150 = lean_box(0); +} +if (lean_is_scalar(x_150)) { + x_151 = lean_alloc_ctor(1, 2, 0); +} else { + x_151 = x_150; +} +lean_ctor_set(x_151, 0, x_148); +lean_ctor_set(x_151, 1, x_149); +x_152 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_152, 0, x_151); +lean_ctor_set(x_152, 1, x_147); +lean_ctor_set(x_14, 0, x_152); +return x_14; +} +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; +x_153 = lean_ctor_get(x_14, 1); +lean_inc(x_153); +lean_dec(x_14); +x_154 = lean_ctor_get(x_15, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_155 = x_15; +} else { + lean_dec_ref(x_15); + x_155 = lean_box(0); +} +x_156 = lean_ctor_get(x_16, 0); +lean_inc(x_156); +x_157 = lean_ctor_get(x_16, 1); +lean_inc(x_157); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_158 = x_16; +} else { + lean_dec_ref(x_16); + x_158 = lean_box(0); +} +if (lean_is_scalar(x_158)) { + x_159 = lean_alloc_ctor(1, 2, 0); +} else { + x_159 = x_158; +} +lean_ctor_set(x_159, 0, x_156); +lean_ctor_set(x_159, 1, x_157); +if (lean_is_scalar(x_155)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_155; +} +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_154); +x_161 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_161, 0, x_160); +lean_ctor_set(x_161, 1, x_153); +return x_161; +} +} +} +else +{ +uint8_t x_162; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_162 = !lean_is_exclusive(x_14); +if (x_162 == 0) +{ +return x_14; +} +else +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_163 = lean_ctor_get(x_14, 0); +x_164 = lean_ctor_get(x_14, 1); +lean_inc(x_164); +lean_inc(x_163); +lean_dec(x_14); +x_165 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_165, 0, x_163); +lean_ctor_set(x_165, 1, x_164); +return x_165; +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildDeps___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("extraDep", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_recBuildDeps___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_recBuildDeps___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = l_Lake_Module_recBuildDeps___closed__2; +lean_inc(x_8); +x_10 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_10, 0, x_8); +lean_ctor_set(x_10, 1, x_9); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +x_11 = lean_apply_6(x_2, x_10, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_15 = x_11; +} else { + lean_dec_ref(x_11); + x_15 = lean_box(0); +} +x_16 = lean_ctor_get(x_12, 1); +lean_inc(x_16); +lean_dec(x_12); +x_17 = lean_ctor_get(x_13, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_13, 1); +lean_inc(x_18); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_19 = x_13; +} else { + lean_dec_ref(x_13); + x_19 = lean_box(0); +} +x_93 = l_Lake_Module_importsFacetConfig___closed__2; +lean_inc(x_1); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_1); +lean_ctor_set(x_94, 1, x_93); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +x_95 = lean_apply_6(x_2, x_94, x_3, x_4, x_18, x_16, x_14); +if (lean_obj_tag(x_95) == 0) +{ +lean_object* x_96; lean_object* x_97; +x_96 = lean_ctor_get(x_95, 0); +lean_inc(x_96); +x_97 = lean_ctor_get(x_96, 0); +lean_inc(x_97); +if (lean_obj_tag(x_97) == 0) +{ +lean_object* x_98; uint8_t x_99; +x_98 = lean_ctor_get(x_95, 1); +lean_inc(x_98); +lean_dec(x_95); +x_99 = !lean_is_exclusive(x_96); +if (x_99 == 0) +{ +lean_object* x_100; uint8_t x_101; +x_100 = lean_ctor_get(x_96, 0); +lean_dec(x_100); +x_101 = !lean_is_exclusive(x_97); +if (x_101 == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_97, 0); +x_103 = lean_box(0); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_102); +lean_ctor_set(x_104, 1, x_103); +lean_ctor_set(x_97, 0, x_104); +x_20 = x_96; +x_21 = x_98; +goto block_92; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_105 = lean_ctor_get(x_97, 0); +x_106 = lean_ctor_get(x_97, 1); +lean_inc(x_106); +lean_inc(x_105); +lean_dec(x_97); +x_107 = lean_box(0); +x_108 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_107); +x_109 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_109, 0, x_108); +lean_ctor_set(x_109, 1, x_106); +lean_ctor_set(x_96, 0, x_109); +x_20 = x_96; +x_21 = x_98; +goto block_92; +} +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_110 = lean_ctor_get(x_96, 1); +lean_inc(x_110); +lean_dec(x_96); +x_111 = lean_ctor_get(x_97, 0); +lean_inc(x_111); +x_112 = lean_ctor_get(x_97, 1); +lean_inc(x_112); +if (lean_is_exclusive(x_97)) { + lean_ctor_release(x_97, 0); + lean_ctor_release(x_97, 1); + x_113 = x_97; +} else { + lean_dec_ref(x_97); + x_113 = lean_box(0); +} +x_114 = lean_box(0); +x_115 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_115, 0, x_111); +lean_ctor_set(x_115, 1, x_114); +if (lean_is_scalar(x_113)) { + x_116 = lean_alloc_ctor(0, 2, 0); +} else { + x_116 = x_113; +} +lean_ctor_set(x_116, 0, x_115); +lean_ctor_set(x_116, 1, x_112); +x_117 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_117, 0, x_116); +lean_ctor_set(x_117, 1, x_110); +x_20 = x_117; +x_21 = x_98; +goto block_92; +} +} +else +{ +lean_object* x_118; uint8_t x_119; +x_118 = lean_ctor_get(x_95, 1); +lean_inc(x_118); +lean_dec(x_95); +x_119 = !lean_is_exclusive(x_96); +if (x_119 == 0) +{ +lean_object* x_120; uint8_t x_121; +x_120 = lean_ctor_get(x_96, 0); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_97); +if (x_121 == 0) +{ +x_20 = x_96; +x_21 = x_118; +goto block_92; +} +else +{ +lean_object* x_122; lean_object* x_123; lean_object* x_124; +x_122 = lean_ctor_get(x_97, 0); +x_123 = lean_ctor_get(x_97, 1); +lean_inc(x_123); +lean_inc(x_122); +lean_dec(x_97); +x_124 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_124, 0, x_122); +lean_ctor_set(x_124, 1, x_123); +lean_ctor_set(x_96, 0, x_124); +x_20 = x_96; +x_21 = x_118; +goto block_92; +} +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; +x_125 = lean_ctor_get(x_96, 1); +lean_inc(x_125); +lean_dec(x_96); +x_126 = lean_ctor_get(x_97, 0); +lean_inc(x_126); +x_127 = lean_ctor_get(x_97, 1); +lean_inc(x_127); +if (lean_is_exclusive(x_97)) { + lean_ctor_release(x_97, 0); + lean_ctor_release(x_97, 1); + x_128 = x_97; +} else { + lean_dec_ref(x_97); + x_128 = lean_box(0); +} +if (lean_is_scalar(x_128)) { + x_129 = lean_alloc_ctor(1, 2, 0); +} else { + x_129 = x_128; +} +lean_ctor_set(x_129, 0, x_126); +lean_ctor_set(x_129, 1, x_127); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_125); +x_20 = x_130; +x_21 = x_118; +goto block_92; +} +} +} +else +{ +uint8_t x_131; +lean_dec(x_19); +lean_dec(x_17); +lean_dec(x_15); +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_131 = !lean_is_exclusive(x_95); +if (x_131 == 0) +{ +return x_95; +} +else +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_132 = lean_ctor_get(x_95, 0); +x_133 = lean_ctor_get(x_95, 1); +lean_inc(x_133); +lean_inc(x_132); +lean_dec(x_95); +x_134 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_134, 0, x_132); +lean_ctor_set(x_134, 1, x_133); +return x_134; +} +} +block_92: +{ +lean_object* x_22; +x_22 = lean_ctor_get(x_20, 0); +lean_inc(x_22); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; +lean_dec(x_19); +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_dec(x_15); +x_24 = lean_ctor_get(x_20, 1); +lean_inc(x_24); +lean_dec(x_20); +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +lean_dec(x_22); +x_26 = lean_ctor_get(x_23, 0); +lean_inc(x_26); +lean_dec(x_23); +x_27 = l_Lake_Module_recBuildDeps___lambda__7(x_1, x_8, x_17, x_26, x_2, x_3, x_4, x_25, x_24, x_21); +return x_27; +} +else +{ +uint8_t x_28; +lean_dec(x_17); +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_28 = !lean_is_exclusive(x_20); +if (x_28 == 0) +{ +lean_object* x_29; uint8_t x_30; +x_29 = lean_ctor_get(x_20, 0); +lean_dec(x_29); +x_30 = !lean_is_exclusive(x_22); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_22, 0); +lean_dec(x_31); +x_32 = lean_ctor_get(x_23, 0); +lean_inc(x_32); +lean_dec(x_23); +lean_ctor_set(x_22, 0, x_32); +if (lean_is_scalar(x_15)) { + x_33 = lean_alloc_ctor(0, 2, 0); +} else { + x_33 = x_15; +} +lean_ctor_set(x_33, 0, x_20); +lean_ctor_set(x_33, 1, x_21); +return x_33; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_34 = lean_ctor_get(x_22, 1); +lean_inc(x_34); +lean_dec(x_22); +x_35 = lean_ctor_get(x_23, 0); +lean_inc(x_35); +lean_dec(x_23); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_34); +lean_ctor_set(x_20, 0, x_36); +if (lean_is_scalar(x_15)) { + x_37 = lean_alloc_ctor(0, 2, 0); +} else { + x_37 = x_15; +} +lean_ctor_set(x_37, 0, x_20); +lean_ctor_set(x_37, 1, x_21); +return x_37; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_38 = lean_ctor_get(x_20, 1); +lean_inc(x_38); +lean_dec(x_20); +x_39 = lean_ctor_get(x_22, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_40 = x_22; +} else { + lean_dec_ref(x_22); + x_40 = lean_box(0); +} +x_41 = lean_ctor_get(x_23, 0); +lean_inc(x_41); +lean_dec(x_23); +if (lean_is_scalar(x_40)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_40; +} +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_39); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +if (lean_is_scalar(x_15)) { + x_44 = lean_alloc_ctor(0, 2, 0); +} else { + x_44 = x_15; +} +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_21); +return x_44; +} +} +} +else +{ +uint8_t x_45; +lean_dec(x_17); +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_45 = !lean_is_exclusive(x_20); +if (x_45 == 0) +{ +lean_object* x_46; uint8_t x_47; +x_46 = lean_ctor_get(x_20, 0); +lean_dec(x_46); +x_47 = !lean_is_exclusive(x_22); +if (x_47 == 0) +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_48 = lean_ctor_get(x_22, 0); +x_49 = lean_ctor_get(x_22, 1); +x_50 = lean_array_get_size(x_49); +lean_inc(x_48); +x_51 = l_Array_extract___rarg(x_49, x_48, x_50); +lean_dec(x_50); +x_52 = l_Array_shrink___rarg(x_49, x_48); +lean_dec(x_48); +x_53 = 0; +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_51); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_53); +x_55 = lean_unsigned_to_nat(0u); +lean_ctor_set(x_22, 1, x_54); +lean_ctor_set(x_22, 0, x_55); +x_56 = lean_task_pure(x_22); +x_57 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_56); +lean_ctor_set(x_58, 1, x_57); +if (lean_is_scalar(x_19)) { + x_59 = lean_alloc_ctor(0, 2, 0); +} else { + x_59 = x_19; +} +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_52); +lean_ctor_set(x_20, 0, x_59); +if (lean_is_scalar(x_15)) { + x_60 = lean_alloc_ctor(0, 2, 0); +} else { + x_60 = x_15; +} +lean_ctor_set(x_60, 0, x_20); +lean_ctor_set(x_60, 1, x_21); +return x_60; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_61 = lean_ctor_get(x_22, 0); +x_62 = lean_ctor_get(x_22, 1); +lean_inc(x_62); +lean_inc(x_61); +lean_dec(x_22); +x_63 = lean_array_get_size(x_62); +lean_inc(x_61); +x_64 = l_Array_extract___rarg(x_62, x_61, x_63); +lean_dec(x_63); +x_65 = l_Array_shrink___rarg(x_62, x_61); +lean_dec(x_61); +x_66 = 0; +x_67 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_67, 0, x_64); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_66); +x_68 = lean_unsigned_to_nat(0u); +x_69 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_task_pure(x_69); +x_71 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +if (lean_is_scalar(x_19)) { + x_73 = lean_alloc_ctor(0, 2, 0); +} else { + x_73 = x_19; +} +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_65); +lean_ctor_set(x_20, 0, x_73); +if (lean_is_scalar(x_15)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_15; +} +lean_ctor_set(x_74, 0, x_20); +lean_ctor_set(x_74, 1, x_21); +return x_74; +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); +lean_dec(x_20); +x_76 = lean_ctor_get(x_22, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_22, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_78 = x_22; +} else { + lean_dec_ref(x_22); + x_78 = lean_box(0); +} +x_79 = lean_array_get_size(x_77); +lean_inc(x_76); +x_80 = l_Array_extract___rarg(x_77, x_76, x_79); +lean_dec(x_79); +x_81 = l_Array_shrink___rarg(x_77, x_76); +lean_dec(x_76); +x_82 = 0; +x_83 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set_uint8(x_83, sizeof(void*)*1, x_82); +x_84 = lean_unsigned_to_nat(0u); +if (lean_is_scalar(x_78)) { + x_85 = lean_alloc_ctor(1, 2, 0); +} else { + x_85 = x_78; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_83); +x_86 = lean_task_pure(x_85); +x_87 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_88 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_88, 0, x_86); +lean_ctor_set(x_88, 1, x_87); +if (lean_is_scalar(x_19)) { + x_89 = lean_alloc_ctor(0, 2, 0); +} else { + x_89 = x_19; +} +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_81); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_75); +if (lean_is_scalar(x_15)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_15; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_21); +return x_91; +} +} +} +} +else +{ +uint8_t x_135; +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_135 = !lean_is_exclusive(x_11); +if (x_135 == 0) +{ +lean_object* x_136; uint8_t x_137; +x_136 = lean_ctor_get(x_11, 0); +lean_dec(x_136); +x_137 = !lean_is_exclusive(x_12); +if (x_137 == 0) +{ +lean_object* x_138; uint8_t x_139; +x_138 = lean_ctor_get(x_12, 0); +lean_dec(x_138); +x_139 = !lean_is_exclusive(x_13); +if (x_139 == 0) +{ +return x_11; +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; +x_140 = lean_ctor_get(x_13, 0); +x_141 = lean_ctor_get(x_13, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_13); +x_142 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_142, 0, x_140); +lean_ctor_set(x_142, 1, x_141); +lean_ctor_set(x_12, 0, x_142); +return x_11; +} +} +else +{ +lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; +x_143 = lean_ctor_get(x_12, 1); +lean_inc(x_143); +lean_dec(x_12); +x_144 = lean_ctor_get(x_13, 0); +lean_inc(x_144); +x_145 = lean_ctor_get(x_13, 1); +lean_inc(x_145); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_146 = x_13; +} else { + lean_dec_ref(x_13); + x_146 = lean_box(0); +} +if (lean_is_scalar(x_146)) { + x_147 = lean_alloc_ctor(1, 2, 0); +} else { + x_147 = x_146; +} +lean_ctor_set(x_147, 0, x_144); +lean_ctor_set(x_147, 1, x_145); +x_148 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_148, 0, x_147); +lean_ctor_set(x_148, 1, x_143); +lean_ctor_set(x_11, 0, x_148); +return x_11; +} +} +else +{ +lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; +x_149 = lean_ctor_get(x_11, 1); +lean_inc(x_149); +lean_dec(x_11); +x_150 = lean_ctor_get(x_12, 1); +lean_inc(x_150); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_151 = x_12; +} else { + lean_dec_ref(x_12); + x_151 = lean_box(0); +} +x_152 = lean_ctor_get(x_13, 0); +lean_inc(x_152); +x_153 = lean_ctor_get(x_13, 1); +lean_inc(x_153); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_154 = x_13; +} else { + lean_dec_ref(x_13); + x_154 = lean_box(0); +} +if (lean_is_scalar(x_154)) { + x_155 = lean_alloc_ctor(1, 2, 0); +} else { + x_155 = x_154; +} +lean_ctor_set(x_155, 0, x_152); +lean_ctor_set(x_155, 1, x_153); +if (lean_is_scalar(x_151)) { + x_156 = lean_alloc_ctor(0, 2, 0); +} else { + x_156 = x_151; +} +lean_ctor_set(x_156, 0, x_155); +lean_ctor_set(x_156, 1, x_150); +x_157 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_157, 0, x_156); +lean_ctor_set(x_157, 1, x_149); +return x_157; +} +} +} +else +{ +uint8_t x_158; +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_158 = !lean_is_exclusive(x_11); +if (x_158 == 0) +{ +return x_11; +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; +x_159 = lean_ctor_get(x_11, 0); +x_160 = lean_ctor_get(x_11, 1); +lean_inc(x_160); +lean_inc(x_159); +lean_dec(x_11); +x_161 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_161, 0, x_159); +lean_ctor_set(x_161, 1, x_160); +return x_161; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; size_t x_11; lean_object* x_12; +x_10 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2(x_10, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_List_elem___at_Lake_Module_recBuildDeps___spec__5___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_List_elem___at_Lake_Module_recBuildDeps___spec__5(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_Module_recBuildDeps___spec__4___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lean_HashSetImp_contains___at_Lake_Module_recBuildDeps___spec__4(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Module_recBuildDeps___spec__11___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_replace___at_Lake_Module_recBuildDeps___spec__11(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__13___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__13(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12(x_1, x_2, x_3); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +size_t x_4; size_t x_5; lean_object* x_6; +x_4 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__14(x_4, x_5, x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; lean_object* x_11; +x_10 = lean_unbox_usize(x_6); +lean_dec(x_6); +x_11 = l_Lake_Module_recBuildDeps___lambda__1(x_1, x_2, x_3, x_4, x_5, x_10, x_7, x_8, x_9); +lean_dec(x_8); +lean_dec(x_4); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; lean_object* x_11; +x_10 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_11 = l_Lake_Module_recBuildDeps___lambda__3(x_1, x_2, x_3, x_4, x_10, x_6, x_7, x_8, x_9); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; lean_object* x_11; +x_10 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_11 = l_Lake_Module_recBuildDeps___lambda__4(x_1, x_2, x_3, x_4, x_10, x_6, x_7, x_8, x_9); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; lean_object* x_11; +x_10 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_11 = l_Lake_Module_recBuildDeps___lambda__5(x_1, x_2, x_3, x_4, x_10, x_6, x_7, x_8, x_9); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDeps___lambda__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; lean_object* x_13; +x_12 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_13 = l_Lake_Module_recBuildDeps___lambda__6(x_12, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_depsFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Module_recBuildDeps(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_dec(x_3); +x_4 = lean_box(0); +lean_ctor_set(x_1, 0, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +} +static lean_object* _init_l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___lambda__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_Module_depsFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_depsFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Module_depsFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_depsFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("deps", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_depsFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_depsFacetConfig___closed__3; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_depsFacetConfig___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_depsFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_depsFacetConfig___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_depsFacetConfig___closed__5; +x_2 = l_Lake_Module_depsFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_depsFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_depsFacetConfig___closed__6; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_clearOutputHashes___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("ilean", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_clearOutputHashes___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("c", 1); +return x_1; +} +} +static uint8_t _init_l_Lake_Module_clearOutputHashes___closed__3() { +_start: +{ +lean_object* x_1; uint8_t x_2; +x_1 = lean_box(0); +x_2 = lean_internal_has_llvm_backend(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_clearOutputHashes___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("bc", 2); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_clearOutputHashes(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_3, 0); +lean_inc(x_4); +lean_dec(x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_4, 2); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_ctor_get(x_6, 8); +lean_inc(x_7); +x_8 = l_System_FilePath_join(x_5, x_7); +x_9 = lean_ctor_get(x_6, 9); +lean_inc(x_9); +lean_inc(x_8); +x_10 = l_System_FilePath_join(x_8, x_9); +x_11 = lean_ctor_get(x_1, 1); +lean_inc(x_11); +lean_dec(x_1); +x_12 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1; +lean_inc(x_11); +x_13 = l_Lean_modToFilePath(x_10, x_11, x_12); +x_14 = l_Lake_clearFileHash(x_13, x_2); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_15 = lean_ctor_get(x_14, 1); +lean_inc(x_15); +lean_dec(x_14); +x_16 = l_Lake_Module_clearOutputHashes___closed__1; +lean_inc(x_11); +x_17 = l_Lean_modToFilePath(x_10, x_11, x_16); +lean_dec(x_10); +x_18 = l_Lake_clearFileHash(x_17, x_15); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_19 = lean_ctor_get(x_18, 1); +lean_inc(x_19); +lean_dec(x_18); +x_20 = lean_ctor_get(x_6, 12); +lean_inc(x_20); +lean_dec(x_6); +x_21 = l_System_FilePath_join(x_8, x_20); +x_22 = l_Lake_Module_clearOutputHashes___closed__2; +lean_inc(x_11); +x_23 = l_Lean_modToFilePath(x_21, x_11, x_22); +x_24 = l_Lake_clearFileHash(x_23, x_19); +if (lean_obj_tag(x_24) == 0) +{ +uint8_t x_25; +x_25 = !lean_is_exclusive(x_24); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; uint8_t x_28; +x_26 = lean_ctor_get(x_24, 1); +x_27 = lean_ctor_get(x_24, 0); +lean_dec(x_27); +x_28 = l_Lake_Module_clearOutputHashes___closed__3; +if (x_28 == 0) +{ +lean_object* x_29; +lean_dec(x_21); +lean_dec(x_11); +x_29 = lean_box(0); +lean_ctor_set(x_24, 0, x_29); +return x_24; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_free_object(x_24); +x_30 = l_Lake_Module_clearOutputHashes___closed__4; +x_31 = l_Lean_modToFilePath(x_21, x_11, x_30); +lean_dec(x_21); +x_32 = l_Lake_clearFileHash(x_31, x_26); +return x_32; +} +} +else +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_24, 1); +lean_inc(x_33); +lean_dec(x_24); +x_34 = l_Lake_Module_clearOutputHashes___closed__3; +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; +lean_dec(x_21); +lean_dec(x_11); +x_35 = lean_box(0); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_33); +return x_36; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = l_Lake_Module_clearOutputHashes___closed__4; +x_38 = l_Lean_modToFilePath(x_21, x_11, x_37); +lean_dec(x_21); +x_39 = l_Lake_clearFileHash(x_38, x_33); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_dec(x_21); +lean_dec(x_11); +x_40 = !lean_is_exclusive(x_24); +if (x_40 == 0) +{ +return x_24; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_24, 0); +x_42 = lean_ctor_get(x_24, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_24); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_6); +x_44 = !lean_is_exclusive(x_18); +if (x_44 == 0) +{ +return x_18; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_18, 0); +x_46 = lean_ctor_get(x_18, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_18); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +x_48 = !lean_is_exclusive(x_14); +if (x_48 == 0) +{ +return x_14; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_14, 0); +x_50 = lean_ctor_get(x_14, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_14); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_cacheOutputHashes(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_3, 0); +lean_inc(x_4); +lean_dec(x_3); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_4, 2); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_ctor_get(x_6, 8); +lean_inc(x_7); +x_8 = l_System_FilePath_join(x_5, x_7); +x_9 = lean_ctor_get(x_6, 9); +lean_inc(x_9); +lean_inc(x_8); +x_10 = l_System_FilePath_join(x_8, x_9); +x_11 = lean_ctor_get(x_1, 1); +lean_inc(x_11); +lean_dec(x_1); +x_12 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1; +lean_inc(x_11); +x_13 = l_Lean_modToFilePath(x_10, x_11, x_12); +x_14 = l_Lake_cacheFileHash(x_13, x_2); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_15 = lean_ctor_get(x_14, 1); +lean_inc(x_15); +lean_dec(x_14); +x_16 = l_Lake_Module_clearOutputHashes___closed__1; +lean_inc(x_11); +x_17 = l_Lean_modToFilePath(x_10, x_11, x_16); +lean_dec(x_10); +x_18 = l_Lake_cacheFileHash(x_17, x_15); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_19 = lean_ctor_get(x_18, 1); +lean_inc(x_19); +lean_dec(x_18); +x_20 = lean_ctor_get(x_6, 12); +lean_inc(x_20); +lean_dec(x_6); +x_21 = l_System_FilePath_join(x_8, x_20); +x_22 = l_Lake_Module_clearOutputHashes___closed__2; +lean_inc(x_11); +x_23 = l_Lean_modToFilePath(x_21, x_11, x_22); +x_24 = l_Lake_cacheFileHash(x_23, x_19); +if (lean_obj_tag(x_24) == 0) +{ +uint8_t x_25; +x_25 = !lean_is_exclusive(x_24); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; uint8_t x_28; +x_26 = lean_ctor_get(x_24, 1); +x_27 = lean_ctor_get(x_24, 0); +lean_dec(x_27); +x_28 = l_Lake_Module_clearOutputHashes___closed__3; +if (x_28 == 0) +{ +lean_object* x_29; +lean_dec(x_21); +lean_dec(x_11); +x_29 = lean_box(0); +lean_ctor_set(x_24, 0, x_29); +return x_24; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_free_object(x_24); +x_30 = l_Lake_Module_clearOutputHashes___closed__4; +x_31 = l_Lean_modToFilePath(x_21, x_11, x_30); +lean_dec(x_21); +x_32 = l_Lake_cacheFileHash(x_31, x_26); +return x_32; +} +} +else +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_24, 1); +lean_inc(x_33); +lean_dec(x_24); +x_34 = l_Lake_Module_clearOutputHashes___closed__3; +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; +lean_dec(x_21); +lean_dec(x_11); +x_35 = lean_box(0); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_33); +return x_36; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = l_Lake_Module_clearOutputHashes___closed__4; +x_38 = l_Lean_modToFilePath(x_21, x_11, x_37); +lean_dec(x_21); +x_39 = l_Lake_cacheFileHash(x_38, x_33); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_dec(x_21); +lean_dec(x_11); +x_40 = !lean_is_exclusive(x_24); +if (x_40 == 0) +{ +return x_24; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_24, 0); +x_42 = lean_ctor_get(x_24, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_24); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_6); +x_44 = !lean_is_exclusive(x_18); +if (x_44 == 0) +{ +return x_18; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_18, 0); +x_46 = lean_ctor_get(x_18, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_18); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +x_48 = !lean_is_exclusive(x_14); +if (x_48 == 0) +{ +return x_14; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_14, 0); +x_50 = lean_ctor_get(x_14, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_14); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_Module_getMTime(x_1, x_3); +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_4, 0); +x_7 = l_Lake_MTime_instOrd; +x_8 = l_instDecidableRelLt___rarg(x_7, x_2, x_6); +x_9 = lean_box(x_8); +lean_ctor_set(x_4, 0, x_9); +return x_4; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; +x_10 = lean_ctor_get(x_4, 0); +x_11 = lean_ctor_get(x_4, 1); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_4); +x_12 = l_Lake_MTime_instOrd; +x_13 = l_instDecidableRelLt___rarg(x_12, x_2, x_10); +x_14 = lean_box(x_13); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_11); +return x_15; +} +} +else +{ +uint8_t x_16; +lean_dec(x_2); +x_16 = !lean_is_exclusive(x_4); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_4, 0); +lean_dec(x_17); +x_18 = 0; +x_19 = lean_box(x_18); +lean_ctor_set_tag(x_4, 0); +lean_ctor_set(x_4, 0, x_19); +return x_4; +} +else +{ +lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; +x_20 = lean_ctor_get(x_4, 1); +lean_inc(x_20); +lean_dec(x_4); +x_21 = 0; +x_22 = lean_box(x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_20); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_Module_recBuildLean___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_2); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_9 = lean_ctor_get(x_2, 0); +x_10 = lean_ctor_get(x_2, 1); +lean_dec(x_10); +x_11 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_11, 0, x_9); +x_12 = l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(x_11, x_3); +if (x_12 == 0) +{ +lean_object* x_13; uint8_t x_14; +x_13 = lean_ctor_get(x_5, 0); +x_14 = lean_ctor_get_uint8(x_13, sizeof(void*)*1); +if (x_14 == 0) +{ +uint8_t x_15; lean_object* x_16; lean_object* x_17; +lean_dec(x_4); +lean_dec(x_1); +x_15 = 0; +x_16 = lean_box(x_15); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_2); +lean_ctor_set(x_17, 1, x_7); +return x_17; +} +else +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_6); +if (x_18 == 0) +{ +lean_object* x_19; uint8_t x_20; +x_19 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_1, x_4, x_7); +x_20 = !lean_is_exclusive(x_19); +if (x_20 == 0) +{ +lean_object* x_21; +x_21 = lean_ctor_get(x_19, 0); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_21); +lean_ctor_set(x_19, 0, x_2); +return x_19; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_19, 0); +x_23 = lean_ctor_get(x_19, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_19); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_2); +lean_ctor_set(x_24, 1, x_23); +return x_24; +} +} +else +{ +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_25 = lean_ctor_get(x_6, 0); +x_26 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +lean_inc(x_25); +lean_dec(x_6); +x_27 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_1, x_4, x_7); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_27, 1); +lean_inc(x_29); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_30 = x_27; +} else { + lean_dec_ref(x_27); + x_30 = lean_box(0); +} +x_31 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_31, 0, x_25); +lean_ctor_set_uint8(x_31, sizeof(void*)*1, x_26); +lean_ctor_set(x_2, 1, x_31); +lean_ctor_set(x_2, 0, x_28); +if (lean_is_scalar(x_30)) { + x_32 = lean_alloc_ctor(0, 2, 0); +} else { + x_32 = x_30; +} +lean_ctor_set(x_32, 0, x_2); +lean_ctor_set(x_32, 1, x_29); +return x_32; +} +} +} +else +{ +uint8_t x_33; +lean_dec(x_4); +x_33 = !lean_is_exclusive(x_6); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = l_Lake_Module_checkExists(x_1, x_7); +x_35 = !lean_is_exclusive(x_34); +if (x_35 == 0) +{ +lean_object* x_36; +x_36 = lean_ctor_get(x_34, 0); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_36); +lean_ctor_set(x_34, 0, x_2); +return x_34; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_34, 0); +x_38 = lean_ctor_get(x_34, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_34); +lean_ctor_set(x_2, 1, x_6); +lean_ctor_set(x_2, 0, x_37); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_2); +lean_ctor_set(x_39, 1, x_38); +return x_39; +} +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_40 = lean_ctor_get(x_6, 0); +x_41 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_6); +x_42 = l_Lake_Module_checkExists(x_1, x_7); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_40); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_41); +lean_ctor_set(x_2, 1, x_46); +lean_ctor_set(x_2, 0, x_43); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_2); +lean_ctor_set(x_47, 1, x_44); +return x_47; +} +} +} +else +{ +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_2, 0); +lean_inc(x_48); +lean_dec(x_2); +x_49 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_49, 0, x_48); +x_50 = l___private_Init_Data_Option_Basic_0__Option_beqOption____x40_Init_Data_Option_Basic___hyg_159____at_Lake_buildFileUnlessUpToDate___spec__5(x_49, x_3); +if (x_50 == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_5, 0); +x_52 = lean_ctor_get_uint8(x_51, sizeof(void*)*1); +if (x_52 == 0) +{ +uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +lean_dec(x_4); +lean_dec(x_1); +x_53 = 0; +x_54 = lean_box(x_53); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_6); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_7); +return x_56; +} +else +{ +lean_object* x_57; uint8_t x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_57 = lean_ctor_get(x_6, 0); +lean_inc(x_57); +x_58 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + x_59 = x_6; +} else { + lean_dec_ref(x_6); + x_59 = lean_box(0); +} +x_60 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_1, x_4, x_7); +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_60, 1); +lean_inc(x_62); +if (lean_is_exclusive(x_60)) { + lean_ctor_release(x_60, 0); + lean_ctor_release(x_60, 1); + x_63 = x_60; +} else { + lean_dec_ref(x_60); + x_63 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_64 = lean_alloc_ctor(0, 1, 1); +} else { + x_64 = x_59; +} +lean_ctor_set(x_64, 0, x_57); +lean_ctor_set_uint8(x_64, sizeof(void*)*1, x_58); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_61); +lean_ctor_set(x_65, 1, x_64); +if (lean_is_scalar(x_63)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_63; +} +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_62); +return x_66; +} +} +else +{ +lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_4); +x_67 = lean_ctor_get(x_6, 0); +lean_inc(x_67); +x_68 = lean_ctor_get_uint8(x_6, sizeof(void*)*1); +if (lean_is_exclusive(x_6)) { + lean_ctor_release(x_6, 0); + x_69 = x_6; +} else { + lean_dec_ref(x_6); + x_69 = lean_box(0); +} +x_70 = l_Lake_Module_checkExists(x_1, x_7); +x_71 = lean_ctor_get(x_70, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_70, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_70)) { + lean_ctor_release(x_70, 0); + lean_ctor_release(x_70, 1); + x_73 = x_70; +} else { + lean_dec_ref(x_70); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_69)) { + x_74 = lean_alloc_ctor(0, 1, 1); +} else { + x_74 = x_69; +} +lean_ctor_set(x_74, 0, x_67); +lean_ctor_set_uint8(x_74, sizeof(void*)*1, x_68); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_71); +lean_ctor_set(x_75, 1, x_74); +if (lean_is_scalar(x_73)) { + x_76 = lean_alloc_ctor(0, 2, 0); +} else { + x_76 = x_73; +} +lean_ctor_set(x_76, 0, x_75); +lean_ctor_set(x_76, 1, x_72); +return x_76; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_4 = lean_ctor_get(x_1, 1); +x_5 = l_Lake_Workspace_leanPath(x_4); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_2); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16) { +_start: +{ +lean_object* x_17; lean_object* x_18; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; uint8_t x_112; +x_92 = lean_ctor_get(x_14, 1); +lean_inc(x_92); +lean_dec(x_14); +x_93 = lean_ctor_get(x_92, 1); +lean_inc(x_93); +lean_dec(x_92); +x_94 = lean_ctor_get(x_93, 1); +lean_inc(x_94); +lean_dec(x_93); +x_95 = lean_ctor_get(x_94, 7); +lean_inc(x_95); +lean_dec(x_94); +x_96 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1; +lean_inc(x_2); +x_97 = l_Lean_modToFilePath(x_1, x_2, x_96); +x_98 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_98, 0, x_97); +x_99 = l_Lake_Module_clearOutputHashes___closed__1; +lean_inc(x_2); +x_100 = l_Lean_modToFilePath(x_1, x_2, x_99); +x_101 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_101, 0, x_100); +x_102 = lean_ctor_get(x_3, 12); +lean_inc(x_102); +lean_dec(x_3); +x_103 = l_System_FilePath_join(x_4, x_102); +x_104 = l_Lake_Module_clearOutputHashes___closed__2; +x_105 = l_Lean_modToFilePath(x_103, x_2, x_104); +lean_dec(x_103); +x_106 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_106, 0, x_105); +lean_inc(x_5); +x_107 = l_Lake_Module_bcFile_x3f(x_5); +x_108 = lean_ctor_get(x_6, 2); +lean_inc(x_108); +lean_dec(x_6); +x_109 = lean_ctor_get(x_7, 2); +x_110 = l_Array_append___rarg(x_108, x_109); +x_111 = l_Array_append___rarg(x_110, x_8); +x_112 = !lean_is_exclusive(x_15); +if (x_112 == 0) +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_113 = lean_ctor_get(x_15, 0); +x_114 = l_Lake_compileLeanModule(x_9, x_98, x_101, x_106, x_107, x_13, x_10, x_11, x_12, x_111, x_95, x_113, x_16); +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; uint8_t x_117; +x_116 = lean_ctor_get(x_114, 1); +lean_inc(x_116); +lean_dec(x_114); +x_117 = !lean_is_exclusive(x_115); +if (x_117 == 0) +{ +lean_object* x_118; +x_118 = lean_ctor_get(x_115, 1); +lean_ctor_set(x_15, 0, x_118); +lean_ctor_set(x_115, 1, x_15); +x_17 = x_115; +x_18 = x_116; +goto block_91; +} +else +{ +lean_object* x_119; lean_object* x_120; lean_object* x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_inc(x_120); +lean_inc(x_119); +lean_dec(x_115); +lean_ctor_set(x_15, 0, x_120); +x_121 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_121, 0, x_119); +lean_ctor_set(x_121, 1, x_15); +x_17 = x_121; +x_18 = x_116; +goto block_91; +} +} +else +{ +lean_object* x_122; uint8_t x_123; +x_122 = lean_ctor_get(x_114, 1); +lean_inc(x_122); +lean_dec(x_114); +x_123 = !lean_is_exclusive(x_115); +if (x_123 == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_115, 1); +lean_ctor_set(x_15, 0, x_124); +lean_ctor_set(x_115, 1, x_15); +x_17 = x_115; +x_18 = x_122; +goto block_91; +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; +x_125 = lean_ctor_get(x_115, 0); +x_126 = lean_ctor_get(x_115, 1); +lean_inc(x_126); +lean_inc(x_125); +lean_dec(x_115); +lean_ctor_set(x_15, 0, x_126); +x_127 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_127, 0, x_125); +lean_ctor_set(x_127, 1, x_15); +x_17 = x_127; +x_18 = x_122; +goto block_91; +} +} +} +else +{ +lean_object* x_128; uint8_t x_129; lean_object* x_130; lean_object* x_131; +x_128 = lean_ctor_get(x_15, 0); +x_129 = lean_ctor_get_uint8(x_15, sizeof(void*)*1); +lean_inc(x_128); +lean_dec(x_15); +x_130 = l_Lake_compileLeanModule(x_9, x_98, x_101, x_106, x_107, x_13, x_10, x_11, x_12, x_111, x_95, x_128, x_16); +x_131 = lean_ctor_get(x_130, 0); +lean_inc(x_131); +if (lean_obj_tag(x_131) == 0) +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_132 = lean_ctor_get(x_130, 1); +lean_inc(x_132); +lean_dec(x_130); +x_133 = lean_ctor_get(x_131, 0); +lean_inc(x_133); +x_134 = lean_ctor_get(x_131, 1); +lean_inc(x_134); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_135 = x_131; +} else { + lean_dec_ref(x_131); + x_135 = lean_box(0); +} +x_136 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_136, 0, x_134); +lean_ctor_set_uint8(x_136, sizeof(void*)*1, x_129); +if (lean_is_scalar(x_135)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_135; +} +lean_ctor_set(x_137, 0, x_133); +lean_ctor_set(x_137, 1, x_136); +x_17 = x_137; +x_18 = x_132; +goto block_91; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_138 = lean_ctor_get(x_130, 1); +lean_inc(x_138); +lean_dec(x_130); +x_139 = lean_ctor_get(x_131, 0); +lean_inc(x_139); +x_140 = lean_ctor_get(x_131, 1); +lean_inc(x_140); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_141 = x_131; +} else { + lean_dec_ref(x_131); + x_141 = lean_box(0); +} +x_142 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_142, 0, x_140); +lean_ctor_set_uint8(x_142, sizeof(void*)*1, x_129); +if (lean_is_scalar(x_141)) { + x_143 = lean_alloc_ctor(1, 2, 0); +} else { + x_143 = x_141; +} +lean_ctor_set(x_143, 0, x_139); +lean_ctor_set(x_143, 1, x_142); +x_17 = x_143; +x_18 = x_138; +goto block_91; +} +} +block_91: +{ +if (lean_obj_tag(x_17) == 0) +{ +uint8_t x_19; +x_19 = !lean_is_exclusive(x_17); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_17, 1); +x_21 = lean_ctor_get(x_17, 0); +lean_dec(x_21); +x_22 = !lean_is_exclusive(x_20); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; +x_23 = lean_ctor_get(x_20, 0); +x_24 = l_Lake_Module_clearOutputHashes(x_5, x_18); +if (lean_obj_tag(x_24) == 0) +{ +uint8_t x_25; +x_25 = !lean_is_exclusive(x_24); +if (x_25 == 0) +{ +lean_object* x_26; +x_26 = lean_ctor_get(x_24, 0); +lean_ctor_set(x_17, 0, x_26); +lean_ctor_set(x_24, 0, x_17); +return x_24; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_24, 0); +x_28 = lean_ctor_get(x_24, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_24); +lean_ctor_set(x_17, 0, x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_17); +lean_ctor_set(x_29, 1, x_28); +return x_29; +} +} +else +{ +uint8_t x_30; +x_30 = !lean_is_exclusive(x_24); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_31 = lean_ctor_get(x_24, 0); +x_32 = lean_io_error_to_string(x_31); +x_33 = 3; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = lean_array_get_size(x_23); +x_36 = lean_array_push(x_23, x_34); +lean_ctor_set(x_20, 0, x_36); +lean_ctor_set_tag(x_17, 1); +lean_ctor_set(x_17, 0, x_35); +lean_ctor_set_tag(x_24, 0); +lean_ctor_set(x_24, 0, x_17); +return x_24; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_37 = lean_ctor_get(x_24, 0); +x_38 = lean_ctor_get(x_24, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_24); +x_39 = lean_io_error_to_string(x_37); +x_40 = 3; +x_41 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set_uint8(x_41, sizeof(void*)*1, x_40); +x_42 = lean_array_get_size(x_23); +x_43 = lean_array_push(x_23, x_41); +lean_ctor_set(x_20, 0, x_43); +lean_ctor_set_tag(x_17, 1); +lean_ctor_set(x_17, 0, x_42); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_17); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +} +} +else +{ +lean_object* x_45; uint8_t x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_20, 0); +x_46 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_45); +lean_dec(x_20); +x_47 = l_Lake_Module_clearOutputHashes(x_5, x_18); +if (lean_obj_tag(x_47) == 0) +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_47, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_50 = x_47; +} else { + lean_dec_ref(x_47); + x_50 = lean_box(0); +} +x_51 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_51, 0, x_45); +lean_ctor_set_uint8(x_51, sizeof(void*)*1, x_46); +lean_ctor_set(x_17, 1, x_51); +lean_ctor_set(x_17, 0, x_48); +if (lean_is_scalar(x_50)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_50; +} +lean_ctor_set(x_52, 0, x_17); +lean_ctor_set(x_52, 1, x_49); +return x_52; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_53 = lean_ctor_get(x_47, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_47, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_55 = x_47; +} else { + lean_dec_ref(x_47); + x_55 = lean_box(0); +} +x_56 = lean_io_error_to_string(x_53); +x_57 = 3; +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_56); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_57); +x_59 = lean_array_get_size(x_45); +x_60 = lean_array_push(x_45, x_58); +x_61 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set_uint8(x_61, sizeof(void*)*1, x_46); +lean_ctor_set_tag(x_17, 1); +lean_ctor_set(x_17, 1, x_61); +lean_ctor_set(x_17, 0, x_59); +if (lean_is_scalar(x_55)) { + x_62 = lean_alloc_ctor(0, 2, 0); +} else { + x_62 = x_55; + lean_ctor_set_tag(x_62, 0); +} +lean_ctor_set(x_62, 0, x_17); +lean_ctor_set(x_62, 1, x_54); +return x_62; +} +} +} +else +{ +lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; lean_object* x_67; +x_63 = lean_ctor_get(x_17, 1); +lean_inc(x_63); +lean_dec(x_17); +x_64 = lean_ctor_get(x_63, 0); +lean_inc(x_64); +x_65 = lean_ctor_get_uint8(x_63, sizeof(void*)*1); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + x_66 = x_63; +} else { + lean_dec_ref(x_63); + x_66 = lean_box(0); +} +x_67 = l_Lake_Module_clearOutputHashes(x_5, x_18); +if (lean_obj_tag(x_67) == 0) +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_68 = lean_ctor_get(x_67, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_67, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_70 = x_67; +} else { + lean_dec_ref(x_67); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_66)) { + x_71 = lean_alloc_ctor(0, 1, 1); +} else { + x_71 = x_66; +} +lean_ctor_set(x_71, 0, x_64); +lean_ctor_set_uint8(x_71, sizeof(void*)*1, x_65); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_68); +lean_ctor_set(x_72, 1, x_71); +if (lean_is_scalar(x_70)) { + x_73 = lean_alloc_ctor(0, 2, 0); +} else { + x_73 = x_70; +} +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_69); +return x_73; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_74 = lean_ctor_get(x_67, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_67, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_76 = x_67; +} else { + lean_dec_ref(x_67); + x_76 = lean_box(0); +} +x_77 = lean_io_error_to_string(x_74); +x_78 = 3; +x_79 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_79, 0, x_77); +lean_ctor_set_uint8(x_79, sizeof(void*)*1, x_78); +x_80 = lean_array_get_size(x_64); +x_81 = lean_array_push(x_64, x_79); +if (lean_is_scalar(x_66)) { + x_82 = lean_alloc_ctor(0, 1, 1); +} else { + x_82 = x_66; +} +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set_uint8(x_82, sizeof(void*)*1, x_65); +x_83 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_82); +if (lean_is_scalar(x_76)) { + x_84 = lean_alloc_ctor(0, 2, 0); +} else { + x_84 = x_76; + lean_ctor_set_tag(x_84, 0); +} +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_75); +return x_84; +} +} +} +else +{ +uint8_t x_85; +lean_dec(x_5); +x_85 = !lean_is_exclusive(x_17); +if (x_85 == 0) +{ +lean_object* x_86; +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_17); +lean_ctor_set(x_86, 1, x_18); +return x_86; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_87 = lean_ctor_get(x_17, 0); +x_88 = lean_ctor_get(x_17, 1); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_17); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_18); +return x_90; +} +} +} +} +} +static uint8_t _init_l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___closed__1() { +_start: +{ +uint32_t x_1; uint8_t x_2; +x_1 = l_Lake_noBuildCode; +x_2 = lean_uint32_to_uint8(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_109; uint8_t x_110; +x_109 = lean_ctor_get(x_7, 0); +lean_inc(x_109); +x_110 = lean_ctor_get_uint8(x_109, sizeof(void*)*1 + 2); +lean_dec(x_109); +if (x_110 == 0) +{ +uint8_t x_111; +x_111 = !lean_is_exclusive(x_8); +if (x_111 == 0) +{ +uint8_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_112 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +x_113 = l_Lake_instOrdJobAction; +x_114 = lean_box(x_112); +x_115 = lean_box(x_5); +x_116 = l_instDecidableRelLe___rarg(x_113, x_114, x_115); +if (x_116 == 0) +{ +lean_object* x_117; lean_object* x_118; +x_117 = lean_box(0); +x_118 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_8); +x_10 = x_118; +x_11 = x_9; +goto block_108; +} +else +{ +lean_object* x_119; lean_object* x_120; +lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_5); +x_119 = lean_box(0); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_8); +x_10 = x_120; +x_11 = x_9; +goto block_108; +} +} +else +{ +lean_object* x_121; uint8_t x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; +x_121 = lean_ctor_get(x_8, 0); +x_122 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_121); +lean_dec(x_8); +x_123 = l_Lake_instOrdJobAction; +x_124 = lean_box(x_122); +x_125 = lean_box(x_5); +x_126 = l_instDecidableRelLe___rarg(x_123, x_124, x_125); +if (x_126 == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_127 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_127, 0, x_121); +lean_ctor_set_uint8(x_127, sizeof(void*)*1, x_122); +x_128 = lean_box(0); +x_129 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set(x_129, 1, x_127); +x_10 = x_129; +x_11 = x_9; +goto block_108; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_130, 0, x_121); +lean_ctor_set_uint8(x_130, sizeof(void*)*1, x_5); +x_131 = lean_box(0); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_130); +x_10 = x_132; +x_11 = x_9; +goto block_108; +} +} +} +else +{ +uint8_t x_133; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_133 = !lean_is_exclusive(x_8); +if (x_133 == 0) +{ +lean_object* x_134; uint8_t x_135; lean_object* x_136; +x_134 = lean_ctor_get(x_8, 0); +x_135 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___closed__1; +x_136 = lean_io_exit(x_135, x_9); +if (lean_obj_tag(x_136) == 0) +{ +uint8_t x_137; +x_137 = !lean_is_exclusive(x_136); +if (x_137 == 0) +{ +lean_object* x_138; lean_object* x_139; +x_138 = lean_ctor_get(x_136, 0); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_8); +lean_ctor_set(x_136, 0, x_139); +return x_136; +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_140 = lean_ctor_get(x_136, 0); +x_141 = lean_ctor_get(x_136, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_136); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_140); +lean_ctor_set(x_142, 1, x_8); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_142); +lean_ctor_set(x_143, 1, x_141); +return x_143; +} +} +else +{ +uint8_t x_144; +x_144 = !lean_is_exclusive(x_136); +if (x_144 == 0) +{ +lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_145 = lean_ctor_get(x_136, 0); +x_146 = lean_io_error_to_string(x_145); +x_147 = 3; +x_148 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_148, 0, x_146); +lean_ctor_set_uint8(x_148, sizeof(void*)*1, x_147); +x_149 = lean_array_get_size(x_134); +x_150 = lean_array_push(x_134, x_148); +lean_ctor_set(x_8, 0, x_150); +x_151 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_151, 0, x_149); +lean_ctor_set(x_151, 1, x_8); +lean_ctor_set_tag(x_136, 0); +lean_ctor_set(x_136, 0, x_151); +return x_136; +} +else +{ +lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_152 = lean_ctor_get(x_136, 0); +x_153 = lean_ctor_get(x_136, 1); +lean_inc(x_153); +lean_inc(x_152); +lean_dec(x_136); +x_154 = lean_io_error_to_string(x_152); +x_155 = 3; +x_156 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_156, 0, x_154); +lean_ctor_set_uint8(x_156, sizeof(void*)*1, x_155); +x_157 = lean_array_get_size(x_134); +x_158 = lean_array_push(x_134, x_156); +lean_ctor_set(x_8, 0, x_158); +x_159 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_159, 0, x_157); +lean_ctor_set(x_159, 1, x_8); +x_160 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_153); +return x_160; +} +} +} +else +{ +lean_object* x_161; uint8_t x_162; uint8_t x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_8, 0); +x_162 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_161); +lean_dec(x_8); +x_163 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___closed__1; +x_164 = lean_io_exit(x_163, x_9); +if (lean_obj_tag(x_164) == 0) +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_165 = lean_ctor_get(x_164, 0); +lean_inc(x_165); +x_166 = lean_ctor_get(x_164, 1); +lean_inc(x_166); +if (lean_is_exclusive(x_164)) { + lean_ctor_release(x_164, 0); + lean_ctor_release(x_164, 1); + x_167 = x_164; +} else { + lean_dec_ref(x_164); + x_167 = lean_box(0); +} +x_168 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_168, 0, x_161); +lean_ctor_set_uint8(x_168, sizeof(void*)*1, x_162); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_165); +lean_ctor_set(x_169, 1, x_168); +if (lean_is_scalar(x_167)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_167; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_166); +return x_170; +} +else +{ +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_171 = lean_ctor_get(x_164, 0); +lean_inc(x_171); +x_172 = lean_ctor_get(x_164, 1); +lean_inc(x_172); +if (lean_is_exclusive(x_164)) { + lean_ctor_release(x_164, 0); + lean_ctor_release(x_164, 1); + x_173 = x_164; +} else { + lean_dec_ref(x_164); + x_173 = lean_box(0); +} +x_174 = lean_io_error_to_string(x_171); +x_175 = 3; +x_176 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_176, 0, x_174); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_175); +x_177 = lean_array_get_size(x_161); +x_178 = lean_array_push(x_161, x_176); +x_179 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_179, 0, x_178); +lean_ctor_set_uint8(x_179, sizeof(void*)*1, x_162); +x_180 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_180, 0, x_177); +lean_ctor_set(x_180, 1, x_179); +if (lean_is_scalar(x_173)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_173; + lean_ctor_set_tag(x_181, 0); +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_172); +return x_181; +} +} +} +block_108: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_array_get_size(x_13); +lean_dec(x_13); +x_15 = l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg(x_1, x_2, x_7, x_12, x_11); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_16); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_18 = lean_ctor_get(x_16, 1); +x_19 = lean_ctor_get(x_16, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 1); +lean_inc(x_20); +lean_dec(x_15); +x_21 = !lean_is_exclusive(x_18); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_18, 0); +x_23 = lean_array_get_size(x_22); +x_24 = l_Array_extract___rarg(x_22, x_14, x_23); +x_25 = l_Lake_writeTraceFile(x_3, x_4, x_24, x_20); +if (lean_obj_tag(x_25) == 0) +{ +uint8_t x_26; +lean_dec(x_23); +x_26 = !lean_is_exclusive(x_25); +if (x_26 == 0) +{ +lean_object* x_27; uint8_t x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_25, 0); +lean_dec(x_27); +x_28 = 0; +x_29 = lean_box(x_28); +lean_ctor_set(x_16, 0, x_29); +lean_ctor_set(x_25, 0, x_16); +return x_25; +} +else +{ +lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_25, 1); +lean_inc(x_30); +lean_dec(x_25); +x_31 = 0; +x_32 = lean_box(x_31); +lean_ctor_set(x_16, 0, x_32); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_16); +lean_ctor_set(x_33, 1, x_30); +return x_33; +} +} +else +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_25); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; +x_35 = lean_ctor_get(x_25, 0); +x_36 = lean_io_error_to_string(x_35); +x_37 = 3; +x_38 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set_uint8(x_38, sizeof(void*)*1, x_37); +x_39 = lean_array_push(x_22, x_38); +lean_ctor_set(x_18, 0, x_39); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 0, x_23); +lean_ctor_set_tag(x_25, 0); +lean_ctor_set(x_25, 0, x_16); +return x_25; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_40 = lean_ctor_get(x_25, 0); +x_41 = lean_ctor_get(x_25, 1); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_25); +x_42 = lean_io_error_to_string(x_40); +x_43 = 3; +x_44 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set_uint8(x_44, sizeof(void*)*1, x_43); +x_45 = lean_array_push(x_22, x_44); +lean_ctor_set(x_18, 0, x_45); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 0, x_23); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_16); +lean_ctor_set(x_46, 1, x_41); +return x_46; +} +} +} +else +{ +lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_47 = lean_ctor_get(x_18, 0); +x_48 = lean_ctor_get_uint8(x_18, sizeof(void*)*1); +lean_inc(x_47); +lean_dec(x_18); +x_49 = lean_array_get_size(x_47); +x_50 = l_Array_extract___rarg(x_47, x_14, x_49); +x_51 = l_Lake_writeTraceFile(x_3, x_4, x_50, x_20); +if (lean_obj_tag(x_51) == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; +lean_dec(x_49); +x_52 = lean_ctor_get(x_51, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_53 = x_51; +} else { + lean_dec_ref(x_51); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_47); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_48); +x_55 = 0; +x_56 = lean_box(x_55); +lean_ctor_set(x_16, 1, x_54); +lean_ctor_set(x_16, 0, x_56); +if (lean_is_scalar(x_53)) { + x_57 = lean_alloc_ctor(0, 2, 0); +} else { + x_57 = x_53; +} +lean_ctor_set(x_57, 0, x_16); +lean_ctor_set(x_57, 1, x_52); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_58 = lean_ctor_get(x_51, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_51, 1); +lean_inc(x_59); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_60 = x_51; +} else { + lean_dec_ref(x_51); + x_60 = lean_box(0); +} +x_61 = lean_io_error_to_string(x_58); +x_62 = 3; +x_63 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set_uint8(x_63, sizeof(void*)*1, x_62); +x_64 = lean_array_push(x_47, x_63); +x_65 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set_uint8(x_65, sizeof(void*)*1, x_48); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 1, x_65); +lean_ctor_set(x_16, 0, x_49); +if (lean_is_scalar(x_60)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_60; + lean_ctor_set_tag(x_66, 0); +} +lean_ctor_set(x_66, 0, x_16); +lean_ctor_set(x_66, 1, x_59); +return x_66; +} +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_67 = lean_ctor_get(x_16, 1); +lean_inc(x_67); +lean_dec(x_16); +x_68 = lean_ctor_get(x_15, 1); +lean_inc(x_68); +lean_dec(x_15); +x_69 = lean_ctor_get(x_67, 0); +lean_inc(x_69); +x_70 = lean_ctor_get_uint8(x_67, sizeof(void*)*1); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + x_71 = x_67; +} else { + lean_dec_ref(x_67); + x_71 = lean_box(0); +} +x_72 = lean_array_get_size(x_69); +x_73 = l_Array_extract___rarg(x_69, x_14, x_72); +x_74 = l_Lake_writeTraceFile(x_3, x_4, x_73, x_68); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_dec(x_72); +x_75 = lean_ctor_get(x_74, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_74)) { + lean_ctor_release(x_74, 0); + lean_ctor_release(x_74, 1); + x_76 = x_74; +} else { + lean_dec_ref(x_74); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_71)) { + x_77 = lean_alloc_ctor(0, 1, 1); +} else { + x_77 = x_71; +} +lean_ctor_set(x_77, 0, x_69); +lean_ctor_set_uint8(x_77, sizeof(void*)*1, x_70); +x_78 = 0; +x_79 = lean_box(x_78); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_77); +if (lean_is_scalar(x_76)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_76; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_75); +return x_81; +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_82 = lean_ctor_get(x_74, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_74, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_74)) { + lean_ctor_release(x_74, 0); + lean_ctor_release(x_74, 1); + x_84 = x_74; +} else { + lean_dec_ref(x_74); + x_84 = lean_box(0); +} +x_85 = lean_io_error_to_string(x_82); +x_86 = 3; +x_87 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set_uint8(x_87, sizeof(void*)*1, x_86); +x_88 = lean_array_push(x_69, x_87); +if (lean_is_scalar(x_71)) { + x_89 = lean_alloc_ctor(0, 1, 1); +} else { + x_89 = x_71; +} +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set_uint8(x_89, sizeof(void*)*1, x_70); +x_90 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_90, 0, x_72); +lean_ctor_set(x_90, 1, x_89); +if (lean_is_scalar(x_84)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_84; + lean_ctor_set_tag(x_91, 0); +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_83); +return x_91; +} +} +} +else +{ +uint8_t x_92; +lean_dec(x_14); +lean_dec(x_4); +lean_dec(x_3); +x_92 = !lean_is_exclusive(x_15); +if (x_92 == 0) +{ +lean_object* x_93; uint8_t x_94; +x_93 = lean_ctor_get(x_15, 0); +lean_dec(x_93); +x_94 = !lean_is_exclusive(x_16); +if (x_94 == 0) +{ +return x_15; +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_95 = lean_ctor_get(x_16, 0); +x_96 = lean_ctor_get(x_16, 1); +lean_inc(x_96); +lean_inc(x_95); +lean_dec(x_16); +x_97 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_97, 0, x_95); +lean_ctor_set(x_97, 1, x_96); +lean_ctor_set(x_15, 0, x_97); +return x_15; +} +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_98 = lean_ctor_get(x_15, 1); +lean_inc(x_98); +lean_dec(x_15); +x_99 = lean_ctor_get(x_16, 0); +lean_inc(x_99); +x_100 = lean_ctor_get(x_16, 1); +lean_inc(x_100); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_101 = x_16; +} else { + lean_dec_ref(x_16); + x_101 = lean_box(0); +} +if (lean_is_scalar(x_101)) { + x_102 = lean_alloc_ctor(1, 2, 0); +} else { + x_102 = x_101; +} +lean_ctor_set(x_102, 0, x_99); +lean_ctor_set(x_102, 1, x_100); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_98); +return x_103; +} +} +} +else +{ +uint8_t x_104; +lean_dec(x_14); +lean_dec(x_4); +lean_dec(x_3); +x_104 = !lean_is_exclusive(x_15); +if (x_104 == 0) +{ +return x_15; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_105 = lean_ctor_get(x_15, 0); +x_106 = lean_ctor_get(x_15, 1); +lean_inc(x_106); +lean_inc(x_105); +lean_dec(x_15); +x_107 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_107, 0, x_105); +lean_ctor_set(x_107, 1, x_106); +return x_107; +} +} +} +} +} +static lean_object* _init_l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__1___boxed), 3, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, uint8_t x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20) { +_start: +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_349; +x_21 = lean_alloc_closure((void*)(l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__2___boxed), 16, 12); +lean_closure_set(x_21, 0, x_12); +lean_closure_set(x_21, 1, x_2); +lean_closure_set(x_21, 2, x_5); +lean_closure_set(x_21, 3, x_11); +lean_closure_set(x_21, 4, x_1); +lean_closure_set(x_21, 5, x_6); +lean_closure_set(x_21, 6, x_7); +lean_closure_set(x_21, 7, x_8); +lean_closure_set(x_21, 8, x_10); +lean_closure_set(x_21, 9, x_9); +lean_closure_set(x_21, 10, x_4); +lean_closure_set(x_21, 11, x_3); +x_349 = !lean_is_exclusive(x_19); +if (x_349 == 0) +{ +lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; uint8_t x_354; +x_350 = lean_ctor_get(x_19, 0); +x_351 = l_Lake_readTraceFile_x3f(x_15, x_350, x_20); +x_352 = lean_ctor_get(x_351, 0); +lean_inc(x_352); +x_353 = lean_ctor_get(x_351, 1); +lean_inc(x_353); +lean_dec(x_351); +x_354 = !lean_is_exclusive(x_352); +if (x_354 == 0) +{ +lean_object* x_355; +x_355 = lean_ctor_get(x_352, 1); +lean_ctor_set(x_19, 0, x_355); +lean_ctor_set(x_352, 1, x_19); +x_22 = x_352; +x_23 = x_353; +goto block_348; +} +else +{ +lean_object* x_356; lean_object* x_357; lean_object* x_358; +x_356 = lean_ctor_get(x_352, 0); +x_357 = lean_ctor_get(x_352, 1); +lean_inc(x_357); +lean_inc(x_356); +lean_dec(x_352); +lean_ctor_set(x_19, 0, x_357); +x_358 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_358, 0, x_356); +lean_ctor_set(x_358, 1, x_19); +x_22 = x_358; +x_23 = x_353; +goto block_348; +} +} +else +{ +lean_object* x_359; uint8_t x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; +x_359 = lean_ctor_get(x_19, 0); +x_360 = lean_ctor_get_uint8(x_19, sizeof(void*)*1); +lean_inc(x_359); +lean_dec(x_19); +x_361 = l_Lake_readTraceFile_x3f(x_15, x_359, x_20); +x_362 = lean_ctor_get(x_361, 0); +lean_inc(x_362); +x_363 = lean_ctor_get(x_361, 1); +lean_inc(x_363); +lean_dec(x_361); +x_364 = lean_ctor_get(x_362, 0); +lean_inc(x_364); +x_365 = lean_ctor_get(x_362, 1); +lean_inc(x_365); +if (lean_is_exclusive(x_362)) { + lean_ctor_release(x_362, 0); + lean_ctor_release(x_362, 1); + x_366 = x_362; +} else { + lean_dec_ref(x_362); + x_366 = lean_box(0); +} +x_367 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_367, 0, x_365); +lean_ctor_set_uint8(x_367, sizeof(void*)*1, x_360); +if (lean_is_scalar(x_366)) { + x_368 = lean_alloc_ctor(0, 2, 0); +} else { + x_368 = x_366; +} +lean_ctor_set(x_368, 0, x_364); +lean_ctor_set(x_368, 1, x_367); +x_22 = x_368; +x_23 = x_363; +goto block_348; +} +block_348: +{ +lean_object* x_24; +x_24 = lean_ctor_get(x_22, 0); +lean_inc(x_24); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_18, 0); +lean_inc(x_25); +x_26 = lean_ctor_get_uint8(x_25, sizeof(void*)*1); +lean_dec(x_25); +if (x_26 == 0) +{ +uint8_t x_27; +lean_dec(x_17); +x_27 = !lean_is_exclusive(x_22); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; uint8_t x_30; +x_28 = lean_ctor_get(x_22, 1); +x_29 = lean_ctor_get(x_22, 0); +lean_dec(x_29); +x_30 = !lean_is_exclusive(x_28); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; uint8_t x_33; +x_31 = lean_ctor_get(x_14, 1); +lean_inc(x_31); +x_32 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_13, x_31, x_23); +x_33 = !lean_is_exclusive(x_32); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_34 = lean_ctor_get(x_32, 0); +x_35 = lean_ctor_get(x_32, 1); +x_36 = lean_unbox(x_34); +lean_dec(x_34); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_free_object(x_32); +lean_free_object(x_22); +x_37 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_38 = lean_box(0); +x_39 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_37, x_21, x_15, x_14, x_16, x_38, x_18, x_28, x_35); +return x_39; +} +else +{ +uint8_t x_40; lean_object* x_41; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_40 = 1; +x_41 = lean_box(x_40); +lean_ctor_set(x_22, 0, x_41); +lean_ctor_set(x_32, 0, x_22); +return x_32; +} +} +else +{ +lean_object* x_42; lean_object* x_43; uint8_t x_44; +x_42 = lean_ctor_get(x_32, 0); +x_43 = lean_ctor_get(x_32, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_32); +x_44 = lean_unbox(x_42); +lean_dec(x_42); +if (x_44 == 0) +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +lean_free_object(x_22); +x_45 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_46 = lean_box(0); +x_47 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_45, x_21, x_15, x_14, x_16, x_46, x_18, x_28, x_43); +return x_47; +} +else +{ +uint8_t x_48; lean_object* x_49; lean_object* x_50; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_48 = 1; +x_49 = lean_box(x_48); +lean_ctor_set(x_22, 0, x_49); +x_50 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_50, 0, x_22); +lean_ctor_set(x_50, 1, x_43); +return x_50; +} +} +} +else +{ +lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; +x_51 = lean_ctor_get(x_28, 0); +x_52 = lean_ctor_get_uint8(x_28, sizeof(void*)*1); +lean_inc(x_51); +lean_dec(x_28); +x_53 = lean_ctor_get(x_14, 1); +lean_inc(x_53); +x_54 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_13, x_53, x_23); +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_51); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_52); +x_59 = lean_unbox(x_55); +lean_dec(x_55); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; +lean_dec(x_57); +lean_free_object(x_22); +x_60 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_61 = lean_box(0); +x_62 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_60, x_21, x_15, x_14, x_16, x_61, x_18, x_58, x_56); +return x_62; +} +else +{ +uint8_t x_63; lean_object* x_64; lean_object* x_65; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_63 = 1; +x_64 = lean_box(x_63); +lean_ctor_set(x_22, 1, x_58); +lean_ctor_set(x_22, 0, x_64); +if (lean_is_scalar(x_57)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_57; +} +lean_ctor_set(x_65, 0, x_22); +lean_ctor_set(x_65, 1, x_56); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; +x_66 = lean_ctor_get(x_22, 1); +lean_inc(x_66); +lean_dec(x_22); +x_67 = lean_ctor_get(x_66, 0); +lean_inc(x_67); +x_68 = lean_ctor_get_uint8(x_66, sizeof(void*)*1); +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + x_69 = x_66; +} else { + lean_dec_ref(x_66); + x_69 = lean_box(0); +} +x_70 = lean_ctor_get(x_14, 1); +lean_inc(x_70); +x_71 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_13, x_70, x_23); +x_72 = lean_ctor_get(x_71, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_71, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_71)) { + lean_ctor_release(x_71, 0); + lean_ctor_release(x_71, 1); + x_74 = x_71; +} else { + lean_dec_ref(x_71); + x_74 = lean_box(0); +} +if (lean_is_scalar(x_69)) { + x_75 = lean_alloc_ctor(0, 1, 1); +} else { + x_75 = x_69; +} +lean_ctor_set(x_75, 0, x_67); +lean_ctor_set_uint8(x_75, sizeof(void*)*1, x_68); +x_76 = lean_unbox(x_72); +lean_dec(x_72); +if (x_76 == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; +lean_dec(x_74); +x_77 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_78 = lean_box(0); +x_79 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_77, x_21, x_15, x_14, x_16, x_78, x_18, x_75, x_73); +return x_79; +} +else +{ +uint8_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_80 = 1; +x_81 = lean_box(x_80); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_75); +if (lean_is_scalar(x_74)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_74; +} +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_73); +return x_83; +} +} +} +else +{ +uint8_t x_84; +x_84 = !lean_is_exclusive(x_22); +if (x_84 == 0) +{ +lean_object* x_85; lean_object* x_86; uint8_t x_87; +x_85 = lean_ctor_get(x_22, 1); +x_86 = lean_ctor_get(x_22, 0); +lean_dec(x_86); +x_87 = !lean_is_exclusive(x_85); +if (x_87 == 0) +{ +lean_object* x_88; uint8_t x_89; +x_88 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_13, x_17, x_23); +x_89 = !lean_is_exclusive(x_88); +if (x_89 == 0) +{ +lean_object* x_90; lean_object* x_91; uint8_t x_92; +x_90 = lean_ctor_get(x_88, 0); +x_91 = lean_ctor_get(x_88, 1); +x_92 = lean_unbox(x_90); +lean_dec(x_90); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_free_object(x_88); +lean_free_object(x_22); +x_93 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_94 = lean_box(0); +x_95 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_93, x_21, x_15, x_14, x_16, x_94, x_18, x_85, x_91); +return x_95; +} +else +{ +uint8_t x_96; lean_object* x_97; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_96 = 1; +x_97 = lean_box(x_96); +lean_ctor_set(x_22, 0, x_97); +lean_ctor_set(x_88, 0, x_22); +return x_88; +} +} +else +{ +lean_object* x_98; lean_object* x_99; uint8_t x_100; +x_98 = lean_ctor_get(x_88, 0); +x_99 = lean_ctor_get(x_88, 1); +lean_inc(x_99); +lean_inc(x_98); +lean_dec(x_88); +x_100 = lean_unbox(x_98); +lean_dec(x_98); +if (x_100 == 0) +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +lean_free_object(x_22); +x_101 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_102 = lean_box(0); +x_103 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_101, x_21, x_15, x_14, x_16, x_102, x_18, x_85, x_99); +return x_103; +} +else +{ +uint8_t x_104; lean_object* x_105; lean_object* x_106; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_104 = 1; +x_105 = lean_box(x_104); +lean_ctor_set(x_22, 0, x_105); +x_106 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_106, 0, x_22); +lean_ctor_set(x_106, 1, x_99); +return x_106; +} +} +} +else +{ +lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; uint8_t x_114; +x_107 = lean_ctor_get(x_85, 0); +x_108 = lean_ctor_get_uint8(x_85, sizeof(void*)*1); +lean_inc(x_107); +lean_dec(x_85); +x_109 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_13, x_17, x_23); +x_110 = lean_ctor_get(x_109, 0); +lean_inc(x_110); +x_111 = lean_ctor_get(x_109, 1); +lean_inc(x_111); +if (lean_is_exclusive(x_109)) { + lean_ctor_release(x_109, 0); + lean_ctor_release(x_109, 1); + x_112 = x_109; +} else { + lean_dec_ref(x_109); + x_112 = lean_box(0); +} +x_113 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_113, 0, x_107); +lean_ctor_set_uint8(x_113, sizeof(void*)*1, x_108); +x_114 = lean_unbox(x_110); +lean_dec(x_110); +if (x_114 == 0) +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; +lean_dec(x_112); +lean_free_object(x_22); +x_115 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_116 = lean_box(0); +x_117 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_115, x_21, x_15, x_14, x_16, x_116, x_18, x_113, x_111); +return x_117; +} +else +{ +uint8_t x_118; lean_object* x_119; lean_object* x_120; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_118 = 1; +x_119 = lean_box(x_118); +lean_ctor_set(x_22, 1, x_113); +lean_ctor_set(x_22, 0, x_119); +if (lean_is_scalar(x_112)) { + x_120 = lean_alloc_ctor(0, 2, 0); +} else { + x_120 = x_112; +} +lean_ctor_set(x_120, 0, x_22); +lean_ctor_set(x_120, 1, x_111); +return x_120; +} +} +} +else +{ +lean_object* x_121; lean_object* x_122; uint8_t 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; uint8_t x_130; +x_121 = lean_ctor_get(x_22, 1); +lean_inc(x_121); +lean_dec(x_22); +x_122 = lean_ctor_get(x_121, 0); +lean_inc(x_122); +x_123 = lean_ctor_get_uint8(x_121, sizeof(void*)*1); +if (lean_is_exclusive(x_121)) { + lean_ctor_release(x_121, 0); + x_124 = x_121; +} else { + lean_dec_ref(x_121); + x_124 = lean_box(0); +} +x_125 = l_Lake_MTime_checkUpToDate___at_Lake_Module_recBuildLean___spec__2(x_13, x_17, x_23); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +x_127 = lean_ctor_get(x_125, 1); +lean_inc(x_127); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + lean_ctor_release(x_125, 1); + x_128 = x_125; +} else { + lean_dec_ref(x_125); + x_128 = lean_box(0); +} +if (lean_is_scalar(x_124)) { + x_129 = lean_alloc_ctor(0, 1, 1); +} else { + x_129 = x_124; +} +lean_ctor_set(x_129, 0, x_122); +lean_ctor_set_uint8(x_129, sizeof(void*)*1, x_123); +x_130 = lean_unbox(x_126); +lean_dec(x_126); +if (x_130 == 0) +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; +lean_dec(x_128); +x_131 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_132 = lean_box(0); +x_133 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_131, x_21, x_15, x_14, x_16, x_132, x_18, x_129, x_127); +return x_133; +} +else +{ +uint8_t x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +lean_dec(x_21); +lean_dec(x_18); +lean_dec(x_15); +lean_dec(x_14); +x_134 = 1; +x_135 = lean_box(x_134); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_135); +lean_ctor_set(x_136, 1, x_129); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_127); +return x_137; +} +} +} +} +else +{ +uint8_t x_138; +x_138 = !lean_is_exclusive(x_24); +if (x_138 == 0) +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; +x_139 = lean_ctor_get(x_24, 0); +x_140 = lean_ctor_get(x_22, 1); +lean_inc(x_140); +lean_dec(x_22); +x_141 = lean_ctor_get(x_139, 0); +lean_inc(x_141); +x_142 = lean_ctor_get(x_139, 1); +lean_inc(x_142); +lean_dec(x_139); +lean_ctor_set(x_24, 0, x_141); +lean_inc(x_14); +x_143 = l_Lake_checkHashUpToDate___at_Lake_Module_recBuildLean___spec__3(x_13, x_14, x_24, x_17, x_18, x_140, x_23); +x_144 = lean_ctor_get(x_143, 0); +lean_inc(x_144); +x_145 = lean_ctor_get(x_143, 1); +lean_inc(x_145); +if (lean_is_exclusive(x_143)) { + lean_ctor_release(x_143, 0); + lean_ctor_release(x_143, 1); + x_146 = x_143; +} else { + lean_dec_ref(x_143); + x_146 = lean_box(0); +} +x_147 = !lean_is_exclusive(x_144); +if (x_147 == 0) +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; uint8_t x_214; +x_148 = lean_ctor_get(x_144, 0); +x_149 = lean_ctor_get(x_144, 1); +x_214 = lean_unbox(x_148); +lean_dec(x_148); +if (x_214 == 0) +{ +lean_object* x_215; lean_object* x_216; lean_object* x_217; +lean_free_object(x_144); +lean_dec(x_146); +lean_dec(x_142); +x_215 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_216 = lean_box(0); +x_217 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_215, x_21, x_15, x_14, x_16, x_216, x_18, x_149, x_145); +return x_217; +} +else +{ +uint8_t x_218; +lean_dec(x_21); +lean_dec(x_15); +lean_dec(x_14); +x_218 = !lean_is_exclusive(x_149); +if (x_218 == 0) +{ +uint8_t x_219; lean_object* x_220; uint8_t x_221; lean_object* x_222; lean_object* x_223; uint8_t x_224; +x_219 = lean_ctor_get_uint8(x_149, sizeof(void*)*1); +x_220 = l_Lake_instOrdJobAction; +x_221 = 1; +x_222 = lean_box(x_219); +x_223 = lean_box(x_221); +x_224 = l_instDecidableRelLe___rarg(x_220, x_222, x_223); +if (x_224 == 0) +{ +lean_object* x_225; +x_225 = lean_box(0); +lean_ctor_set(x_144, 0, x_225); +x_150 = x_144; +x_151 = x_145; +goto block_213; +} +else +{ +lean_object* x_226; +lean_ctor_set_uint8(x_149, sizeof(void*)*1, x_221); +x_226 = lean_box(0); +lean_ctor_set(x_144, 0, x_226); +x_150 = x_144; +x_151 = x_145; +goto block_213; +} +} +else +{ +lean_object* x_227; uint8_t x_228; lean_object* x_229; uint8_t x_230; lean_object* x_231; lean_object* x_232; uint8_t x_233; +x_227 = lean_ctor_get(x_149, 0); +x_228 = lean_ctor_get_uint8(x_149, sizeof(void*)*1); +lean_inc(x_227); +lean_dec(x_149); +x_229 = l_Lake_instOrdJobAction; +x_230 = 1; +x_231 = lean_box(x_228); +x_232 = lean_box(x_230); +x_233 = l_instDecidableRelLe___rarg(x_229, x_231, x_232); +if (x_233 == 0) +{ +lean_object* x_234; lean_object* x_235; +x_234 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_234, 0, x_227); +lean_ctor_set_uint8(x_234, sizeof(void*)*1, x_228); +x_235 = lean_box(0); +lean_ctor_set(x_144, 1, x_234); +lean_ctor_set(x_144, 0, x_235); +x_150 = x_144; +x_151 = x_145; +goto block_213; +} +else +{ +lean_object* x_236; lean_object* x_237; +x_236 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_236, 0, x_227); +lean_ctor_set_uint8(x_236, sizeof(void*)*1, x_230); +x_237 = lean_box(0); +lean_ctor_set(x_144, 1, x_236); +lean_ctor_set(x_144, 0, x_237); +x_150 = x_144; +x_151 = x_145; +goto block_213; +} +} +} +block_213: +{ +uint8_t x_152; +x_152 = !lean_is_exclusive(x_150); +if (x_152 == 0) +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; uint8_t x_157; +x_153 = lean_ctor_get(x_150, 1); +x_154 = lean_ctor_get(x_150, 0); +lean_dec(x_154); +x_155 = lean_array_get_size(x_142); +x_156 = lean_unsigned_to_nat(0u); +x_157 = lean_nat_dec_lt(x_156, x_155); +if (x_157 == 0) +{ +uint8_t x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +lean_dec(x_142); +lean_dec(x_18); +x_158 = 1; +x_159 = lean_box(x_158); +lean_ctor_set(x_150, 0, x_159); +if (lean_is_scalar(x_146)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_146; +} +lean_ctor_set(x_160, 0, x_150); +lean_ctor_set(x_160, 1, x_151); +return x_160; +} +else +{ +uint8_t x_161; +x_161 = lean_nat_dec_le(x_155, x_155); +if (x_161 == 0) +{ +uint8_t x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_155); +lean_dec(x_142); +lean_dec(x_18); +x_162 = 1; +x_163 = lean_box(x_162); +lean_ctor_set(x_150, 0, x_163); +if (lean_is_scalar(x_146)) { + x_164 = lean_alloc_ctor(0, 2, 0); +} else { + x_164 = x_146; +} +lean_ctor_set(x_164, 0, x_150); +lean_ctor_set(x_164, 1, x_151); +return x_164; +} +else +{ +size_t x_165; size_t x_166; lean_object* x_167; lean_object* x_168; uint8_t x_169; +lean_free_object(x_150); +lean_dec(x_146); +x_165 = 0; +x_166 = lean_usize_of_nat(x_155); +lean_dec(x_155); +x_167 = lean_box(0); +x_168 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_142, x_165, x_166, x_167, x_18, x_153, x_151); +lean_dec(x_18); +lean_dec(x_142); +x_169 = !lean_is_exclusive(x_168); +if (x_169 == 0) +{ +lean_object* x_170; uint8_t x_171; +x_170 = lean_ctor_get(x_168, 0); +x_171 = !lean_is_exclusive(x_170); +if (x_171 == 0) +{ +lean_object* x_172; uint8_t x_173; lean_object* x_174; +x_172 = lean_ctor_get(x_170, 0); +lean_dec(x_172); +x_173 = 1; +x_174 = lean_box(x_173); +lean_ctor_set(x_170, 0, x_174); +return x_168; +} +else +{ +lean_object* x_175; uint8_t x_176; lean_object* x_177; lean_object* x_178; +x_175 = lean_ctor_get(x_170, 1); +lean_inc(x_175); +lean_dec(x_170); +x_176 = 1; +x_177 = lean_box(x_176); +x_178 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_175); +lean_ctor_set(x_168, 0, x_178); +return x_168; +} +} +else +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; uint8_t x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; +x_179 = lean_ctor_get(x_168, 0); +x_180 = lean_ctor_get(x_168, 1); +lean_inc(x_180); +lean_inc(x_179); +lean_dec(x_168); +x_181 = lean_ctor_get(x_179, 1); +lean_inc(x_181); +if (lean_is_exclusive(x_179)) { + lean_ctor_release(x_179, 0); + lean_ctor_release(x_179, 1); + x_182 = x_179; +} else { + lean_dec_ref(x_179); + x_182 = lean_box(0); +} +x_183 = 1; +x_184 = lean_box(x_183); +if (lean_is_scalar(x_182)) { + x_185 = lean_alloc_ctor(0, 2, 0); +} else { + x_185 = x_182; +} +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_181); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_180); +return x_186; +} +} +} +} +else +{ +lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; +x_187 = lean_ctor_get(x_150, 1); +lean_inc(x_187); +lean_dec(x_150); +x_188 = lean_array_get_size(x_142); +x_189 = lean_unsigned_to_nat(0u); +x_190 = lean_nat_dec_lt(x_189, x_188); +if (x_190 == 0) +{ +uint8_t x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; +lean_dec(x_188); +lean_dec(x_142); +lean_dec(x_18); +x_191 = 1; +x_192 = lean_box(x_191); +x_193 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_193, 0, x_192); +lean_ctor_set(x_193, 1, x_187); +if (lean_is_scalar(x_146)) { + x_194 = lean_alloc_ctor(0, 2, 0); +} else { + x_194 = x_146; +} +lean_ctor_set(x_194, 0, x_193); +lean_ctor_set(x_194, 1, x_151); +return x_194; +} +else +{ +uint8_t x_195; +x_195 = lean_nat_dec_le(x_188, x_188); +if (x_195 == 0) +{ +uint8_t x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; +lean_dec(x_188); +lean_dec(x_142); +lean_dec(x_18); +x_196 = 1; +x_197 = lean_box(x_196); +x_198 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_187); +if (lean_is_scalar(x_146)) { + x_199 = lean_alloc_ctor(0, 2, 0); +} else { + x_199 = x_146; +} +lean_ctor_set(x_199, 0, x_198); +lean_ctor_set(x_199, 1, x_151); +return x_199; +} +else +{ +size_t x_200; size_t x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; uint8_t x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; +lean_dec(x_146); +x_200 = 0; +x_201 = lean_usize_of_nat(x_188); +lean_dec(x_188); +x_202 = lean_box(0); +x_203 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_142, x_200, x_201, x_202, x_18, x_187, x_151); +lean_dec(x_18); +lean_dec(x_142); +x_204 = lean_ctor_get(x_203, 0); +lean_inc(x_204); +x_205 = lean_ctor_get(x_203, 1); +lean_inc(x_205); +if (lean_is_exclusive(x_203)) { + lean_ctor_release(x_203, 0); + lean_ctor_release(x_203, 1); + x_206 = x_203; +} else { + lean_dec_ref(x_203); + x_206 = lean_box(0); +} +x_207 = lean_ctor_get(x_204, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_204)) { + lean_ctor_release(x_204, 0); + lean_ctor_release(x_204, 1); + x_208 = x_204; +} else { + lean_dec_ref(x_204); + x_208 = lean_box(0); +} +x_209 = 1; +x_210 = lean_box(x_209); +if (lean_is_scalar(x_208)) { + x_211 = lean_alloc_ctor(0, 2, 0); +} else { + x_211 = x_208; +} +lean_ctor_set(x_211, 0, x_210); +lean_ctor_set(x_211, 1, x_207); +if (lean_is_scalar(x_206)) { + x_212 = lean_alloc_ctor(0, 2, 0); +} else { + x_212 = x_206; +} +lean_ctor_set(x_212, 0, x_211); +lean_ctor_set(x_212, 1, x_205); +return x_212; +} +} +} +} +} +else +{ +lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; uint8_t x_270; +x_238 = lean_ctor_get(x_144, 0); +x_239 = lean_ctor_get(x_144, 1); +lean_inc(x_239); +lean_inc(x_238); +lean_dec(x_144); +x_270 = lean_unbox(x_238); +lean_dec(x_238); +if (x_270 == 0) +{ +lean_object* x_271; lean_object* x_272; lean_object* x_273; +lean_dec(x_146); +lean_dec(x_142); +x_271 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_272 = lean_box(0); +x_273 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_271, x_21, x_15, x_14, x_16, x_272, x_18, x_239, x_145); +return x_273; +} +else +{ +lean_object* x_274; uint8_t x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; uint8_t x_281; +lean_dec(x_21); +lean_dec(x_15); +lean_dec(x_14); +x_274 = lean_ctor_get(x_239, 0); +lean_inc(x_274); +x_275 = lean_ctor_get_uint8(x_239, sizeof(void*)*1); +if (lean_is_exclusive(x_239)) { + lean_ctor_release(x_239, 0); + x_276 = x_239; +} else { + lean_dec_ref(x_239); + x_276 = lean_box(0); +} +x_277 = l_Lake_instOrdJobAction; +x_278 = 1; +x_279 = lean_box(x_275); +x_280 = lean_box(x_278); +x_281 = l_instDecidableRelLe___rarg(x_277, x_279, x_280); +if (x_281 == 0) +{ +lean_object* x_282; lean_object* x_283; lean_object* x_284; +if (lean_is_scalar(x_276)) { + x_282 = lean_alloc_ctor(0, 1, 1); +} else { + x_282 = x_276; +} +lean_ctor_set(x_282, 0, x_274); +lean_ctor_set_uint8(x_282, sizeof(void*)*1, x_275); +x_283 = lean_box(0); +x_284 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_284, 0, x_283); +lean_ctor_set(x_284, 1, x_282); +x_240 = x_284; +x_241 = x_145; +goto block_269; +} +else +{ +lean_object* x_285; lean_object* x_286; lean_object* x_287; +if (lean_is_scalar(x_276)) { + x_285 = lean_alloc_ctor(0, 1, 1); +} else { + x_285 = x_276; +} +lean_ctor_set(x_285, 0, x_274); +lean_ctor_set_uint8(x_285, sizeof(void*)*1, x_278); +x_286 = lean_box(0); +x_287 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_287, 0, x_286); +lean_ctor_set(x_287, 1, x_285); +x_240 = x_287; +x_241 = x_145; +goto block_269; +} +} +block_269: +{ +lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; +x_242 = lean_ctor_get(x_240, 1); +lean_inc(x_242); +if (lean_is_exclusive(x_240)) { + lean_ctor_release(x_240, 0); + lean_ctor_release(x_240, 1); + x_243 = x_240; +} else { + lean_dec_ref(x_240); + x_243 = lean_box(0); +} +x_244 = lean_array_get_size(x_142); +x_245 = lean_unsigned_to_nat(0u); +x_246 = lean_nat_dec_lt(x_245, x_244); +if (x_246 == 0) +{ +uint8_t x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; +lean_dec(x_244); +lean_dec(x_142); +lean_dec(x_18); +x_247 = 1; +x_248 = lean_box(x_247); +if (lean_is_scalar(x_243)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_243; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_242); +if (lean_is_scalar(x_146)) { + x_250 = lean_alloc_ctor(0, 2, 0); +} else { + x_250 = x_146; +} +lean_ctor_set(x_250, 0, x_249); +lean_ctor_set(x_250, 1, x_241); +return x_250; +} +else +{ +uint8_t x_251; +x_251 = lean_nat_dec_le(x_244, x_244); +if (x_251 == 0) +{ +uint8_t x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; +lean_dec(x_244); +lean_dec(x_142); +lean_dec(x_18); +x_252 = 1; +x_253 = lean_box(x_252); +if (lean_is_scalar(x_243)) { + x_254 = lean_alloc_ctor(0, 2, 0); +} else { + x_254 = x_243; +} +lean_ctor_set(x_254, 0, x_253); +lean_ctor_set(x_254, 1, x_242); +if (lean_is_scalar(x_146)) { + x_255 = lean_alloc_ctor(0, 2, 0); +} else { + x_255 = x_146; +} +lean_ctor_set(x_255, 0, x_254); +lean_ctor_set(x_255, 1, x_241); +return x_255; +} +else +{ +size_t x_256; size_t x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_243); +lean_dec(x_146); +x_256 = 0; +x_257 = lean_usize_of_nat(x_244); +lean_dec(x_244); +x_258 = lean_box(0); +x_259 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_142, x_256, x_257, x_258, x_18, x_242, x_241); +lean_dec(x_18); +lean_dec(x_142); +x_260 = lean_ctor_get(x_259, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_259, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_259)) { + lean_ctor_release(x_259, 0); + lean_ctor_release(x_259, 1); + x_262 = x_259; +} else { + lean_dec_ref(x_259); + x_262 = lean_box(0); +} +x_263 = lean_ctor_get(x_260, 1); +lean_inc(x_263); +if (lean_is_exclusive(x_260)) { + lean_ctor_release(x_260, 0); + lean_ctor_release(x_260, 1); + x_264 = x_260; +} else { + lean_dec_ref(x_260); + x_264 = lean_box(0); +} +x_265 = 1; +x_266 = lean_box(x_265); +if (lean_is_scalar(x_264)) { + x_267 = lean_alloc_ctor(0, 2, 0); +} else { + x_267 = x_264; +} +lean_ctor_set(x_267, 0, x_266); +lean_ctor_set(x_267, 1, x_263); +if (lean_is_scalar(x_262)) { + x_268 = lean_alloc_ctor(0, 2, 0); +} else { + x_268 = x_262; +} +lean_ctor_set(x_268, 0, x_267); +lean_ctor_set(x_268, 1, x_261); +return x_268; +} +} +} +} +} +else +{ +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; lean_object* x_300; lean_object* x_301; uint8_t x_330; +x_288 = lean_ctor_get(x_24, 0); +lean_inc(x_288); +lean_dec(x_24); +x_289 = lean_ctor_get(x_22, 1); +lean_inc(x_289); +lean_dec(x_22); +x_290 = lean_ctor_get(x_288, 0); +lean_inc(x_290); +x_291 = lean_ctor_get(x_288, 1); +lean_inc(x_291); +lean_dec(x_288); +x_292 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_292, 0, x_290); +lean_inc(x_14); +x_293 = l_Lake_checkHashUpToDate___at_Lake_Module_recBuildLean___spec__3(x_13, x_14, x_292, x_17, x_18, x_289, x_23); +x_294 = lean_ctor_get(x_293, 0); +lean_inc(x_294); +x_295 = lean_ctor_get(x_293, 1); +lean_inc(x_295); +if (lean_is_exclusive(x_293)) { + lean_ctor_release(x_293, 0); + lean_ctor_release(x_293, 1); + x_296 = x_293; +} else { + lean_dec_ref(x_293); + x_296 = lean_box(0); +} +x_297 = lean_ctor_get(x_294, 0); +lean_inc(x_297); +x_298 = lean_ctor_get(x_294, 1); +lean_inc(x_298); +if (lean_is_exclusive(x_294)) { + lean_ctor_release(x_294, 0); + lean_ctor_release(x_294, 1); + x_299 = x_294; +} else { + lean_dec_ref(x_294); + x_299 = lean_box(0); +} +x_330 = lean_unbox(x_297); +lean_dec(x_297); +if (x_330 == 0) +{ +lean_object* x_331; lean_object* x_332; lean_object* x_333; +lean_dec(x_299); +lean_dec(x_296); +lean_dec(x_291); +x_331 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1; +x_332 = lean_box(0); +x_333 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_331, x_21, x_15, x_14, x_16, x_332, x_18, x_298, x_295); +return x_333; +} +else +{ +lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; uint8_t x_338; lean_object* x_339; lean_object* x_340; uint8_t x_341; +lean_dec(x_21); +lean_dec(x_15); +lean_dec(x_14); +x_334 = lean_ctor_get(x_298, 0); +lean_inc(x_334); +x_335 = lean_ctor_get_uint8(x_298, sizeof(void*)*1); +if (lean_is_exclusive(x_298)) { + lean_ctor_release(x_298, 0); + x_336 = x_298; +} else { + lean_dec_ref(x_298); + x_336 = lean_box(0); +} +x_337 = l_Lake_instOrdJobAction; +x_338 = 1; +x_339 = lean_box(x_335); +x_340 = lean_box(x_338); +x_341 = l_instDecidableRelLe___rarg(x_337, x_339, x_340); +if (x_341 == 0) +{ +lean_object* x_342; lean_object* x_343; lean_object* x_344; +if (lean_is_scalar(x_336)) { + x_342 = lean_alloc_ctor(0, 1, 1); +} else { + x_342 = x_336; +} +lean_ctor_set(x_342, 0, x_334); +lean_ctor_set_uint8(x_342, sizeof(void*)*1, x_335); +x_343 = lean_box(0); +if (lean_is_scalar(x_299)) { + x_344 = lean_alloc_ctor(0, 2, 0); +} else { + x_344 = x_299; +} +lean_ctor_set(x_344, 0, x_343); +lean_ctor_set(x_344, 1, x_342); +x_300 = x_344; +x_301 = x_295; +goto block_329; +} +else +{ +lean_object* x_345; lean_object* x_346; lean_object* x_347; +if (lean_is_scalar(x_336)) { + x_345 = lean_alloc_ctor(0, 1, 1); +} else { + x_345 = x_336; +} +lean_ctor_set(x_345, 0, x_334); +lean_ctor_set_uint8(x_345, sizeof(void*)*1, x_338); +x_346 = lean_box(0); +if (lean_is_scalar(x_299)) { + x_347 = lean_alloc_ctor(0, 2, 0); +} else { + x_347 = x_299; +} +lean_ctor_set(x_347, 0, x_346); +lean_ctor_set(x_347, 1, x_345); +x_300 = x_347; +x_301 = x_295; +goto block_329; +} +} +block_329: +{ +lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; uint8_t x_306; +x_302 = lean_ctor_get(x_300, 1); +lean_inc(x_302); +if (lean_is_exclusive(x_300)) { + lean_ctor_release(x_300, 0); + lean_ctor_release(x_300, 1); + x_303 = x_300; +} else { + lean_dec_ref(x_300); + x_303 = lean_box(0); +} +x_304 = lean_array_get_size(x_291); +x_305 = lean_unsigned_to_nat(0u); +x_306 = lean_nat_dec_lt(x_305, x_304); +if (x_306 == 0) +{ +uint8_t x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_304); +lean_dec(x_291); +lean_dec(x_18); +x_307 = 1; +x_308 = lean_box(x_307); +if (lean_is_scalar(x_303)) { + x_309 = lean_alloc_ctor(0, 2, 0); +} else { + x_309 = x_303; +} +lean_ctor_set(x_309, 0, x_308); +lean_ctor_set(x_309, 1, x_302); +if (lean_is_scalar(x_296)) { + x_310 = lean_alloc_ctor(0, 2, 0); +} else { + x_310 = x_296; +} +lean_ctor_set(x_310, 0, x_309); +lean_ctor_set(x_310, 1, x_301); +return x_310; +} +else +{ +uint8_t x_311; +x_311 = lean_nat_dec_le(x_304, x_304); +if (x_311 == 0) +{ +uint8_t x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; +lean_dec(x_304); +lean_dec(x_291); +lean_dec(x_18); +x_312 = 1; +x_313 = lean_box(x_312); +if (lean_is_scalar(x_303)) { + x_314 = lean_alloc_ctor(0, 2, 0); +} else { + x_314 = x_303; +} +lean_ctor_set(x_314, 0, x_313); +lean_ctor_set(x_314, 1, x_302); +if (lean_is_scalar(x_296)) { + x_315 = lean_alloc_ctor(0, 2, 0); +} else { + x_315 = x_296; +} +lean_ctor_set(x_315, 0, x_314); +lean_ctor_set(x_315, 1, x_301); +return x_315; +} +else +{ +size_t x_316; size_t x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; uint8_t x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; +lean_dec(x_303); +lean_dec(x_296); +x_316 = 0; +x_317 = lean_usize_of_nat(x_304); +lean_dec(x_304); +x_318 = lean_box(0); +x_319 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_291, x_316, x_317, x_318, x_18, x_302, x_301); +lean_dec(x_18); +lean_dec(x_291); +x_320 = lean_ctor_get(x_319, 0); +lean_inc(x_320); +x_321 = lean_ctor_get(x_319, 1); +lean_inc(x_321); +if (lean_is_exclusive(x_319)) { + lean_ctor_release(x_319, 0); + lean_ctor_release(x_319, 1); + x_322 = x_319; +} else { + lean_dec_ref(x_319); + x_322 = lean_box(0); +} +x_323 = lean_ctor_get(x_320, 1); +lean_inc(x_323); +if (lean_is_exclusive(x_320)) { + lean_ctor_release(x_320, 0); + lean_ctor_release(x_320, 1); + x_324 = x_320; +} else { + lean_dec_ref(x_320); + x_324 = lean_box(0); +} +x_325 = 1; +x_326 = lean_box(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); +if (lean_is_scalar(x_322)) { + x_328 = lean_alloc_ctor(0, 2, 0); +} else { + x_328 = x_322; +} +lean_ctor_set(x_328, 0, x_327); +lean_ctor_set(x_328, 1, x_321); +return x_328; +} +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Module_recBuildLean___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Module_recBuildLean___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Module_recBuildLean___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_ByteArray_empty; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Init.Data.String.Extra", 22); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("String.fromUTF8!", 16); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid UTF-8 string", 20); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5() { +_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_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__2; +x_2 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__3; +x_3 = lean_unsigned_to_nat(92u); +x_4 = lean_unsigned_to_nat(47u); +x_5 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__4; +x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Module_recBuildLean___spec__5), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_Module_recBuildLean___spec__6(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Module_recBuildLean___spec__7), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Module_recBuildLean___spec__5), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_Module_recBuildLean___spec__6(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Module_recBuildLean___spec__5), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_Module_recBuildLean___spec__6(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Module_recBuildLean___spec__7), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Module_recBuildLean___spec__5), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_Module_recBuildLean___spec__6(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_3); +x_9 = lean_apply_6(x_1, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = lean_apply_7(x_2, x_14, x_3, x_4, x_5, x_15, x_13, x_12); +return x_16; +} +else +{ +uint8_t x_17; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_17 = !lean_is_exclusive(x_9); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_ctor_get(x_9, 0); +lean_dec(x_18); +x_19 = !lean_is_exclusive(x_10); +if (x_19 == 0) +{ +lean_object* x_20; uint8_t x_21; +x_20 = lean_ctor_get(x_10, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_11); +if (x_21 == 0) +{ +return x_9; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_11); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +lean_ctor_set(x_10, 0, x_24); +return x_9; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 1); +lean_inc(x_25); +lean_dec(x_10); +x_26 = lean_ctor_get(x_11, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_11, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_28 = x_11; +} else { + lean_dec_ref(x_11); + x_28 = lean_box(0); +} +if (lean_is_scalar(x_28)) { + x_29 = lean_alloc_ctor(1, 2, 0); +} else { + x_29 = x_28; +} +lean_ctor_set(x_29, 0, x_26); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 1); +lean_inc(x_32); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_33 = x_10; +} else { + lean_dec_ref(x_10); + x_33 = lean_box(0); +} +x_34 = lean_ctor_get(x_11, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_11, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_36 = x_11; +} else { + lean_dec_ref(x_11); + x_36 = lean_box(0); +} +if (lean_is_scalar(x_36)) { + x_37 = lean_alloc_ctor(1, 2, 0); +} else { + x_37 = x_36; +} +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_35); +if (lean_is_scalar(x_33)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_33; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_32); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_31); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +return x_9; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_9, 0); +x_42 = lean_ctor_get(x_9, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_9); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_3, 0); +x_7 = l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(x_1, x_4); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_3); +lean_ctor_set(x_7, 0, x_10); +return x_7; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get(x_7, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_7); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_3); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +return x_14; +} +} +else +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_7); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_16 = lean_ctor_get(x_7, 0); +x_17 = lean_io_error_to_string(x_16); +x_18 = 3; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = lean_array_get_size(x_6); +x_21 = lean_array_push(x_6, x_19); +lean_ctor_set(x_3, 0, x_21); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_3); +lean_ctor_set_tag(x_7, 0); +lean_ctor_set(x_7, 0, x_22); +return x_7; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_23 = lean_ctor_get(x_7, 0); +x_24 = lean_ctor_get(x_7, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_7); +x_25 = lean_io_error_to_string(x_23); +x_26 = 3; +x_27 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set_uint8(x_27, sizeof(void*)*1, x_26); +x_28 = lean_array_get_size(x_6); +x_29 = lean_array_push(x_6, x_27); +lean_ctor_set(x_3, 0, x_29); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_3); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_24); +return x_31; +} +} +} +else +{ +lean_object* x_32; uint8_t x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_3, 0); +x_33 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_32); +lean_dec(x_3); +x_34 = l_Lake_BuildTrace_compute___at_Lake_inputTextFile___spec__1(x_1, x_4); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_35 = lean_ctor_get(x_34, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_34, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_34)) { + lean_ctor_release(x_34, 0); + lean_ctor_release(x_34, 1); + x_37 = x_34; +} else { + lean_dec_ref(x_34); + x_37 = lean_box(0); +} +x_38 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_38, 0, x_32); +lean_ctor_set_uint8(x_38, sizeof(void*)*1, x_33); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_35); +lean_ctor_set(x_39, 1, x_38); +if (lean_is_scalar(x_37)) { + x_40 = lean_alloc_ctor(0, 2, 0); +} else { + x_40 = x_37; +} +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_36); +return x_40; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_41 = lean_ctor_get(x_34, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_34, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_34)) { + lean_ctor_release(x_34, 0); + lean_ctor_release(x_34, 1); + x_43 = x_34; +} else { + lean_dec_ref(x_34); + x_43 = lean_box(0); +} +x_44 = lean_io_error_to_string(x_41); +x_45 = 3; +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_45); +x_47 = lean_array_get_size(x_32); +x_48 = lean_array_push(x_32, x_46); +x_49 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set_uint8(x_49, sizeof(void*)*1, x_33); +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_49); +if (lean_is_scalar(x_43)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_43; + lean_ctor_set_tag(x_51, 0); +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_42); +return x_51; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_1); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_4); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_5); +return x_9; +} +} +static lean_object* _init_l_Lake_Module_recBuildLean___lambda__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("trace", 5); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17) { +_start: +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; lean_object* x_30; +x_18 = lean_ctor_get(x_15, 2); +lean_inc(x_18); +lean_inc(x_1); +lean_inc(x_14); +x_19 = l_Lake_BuildTrace_mix(x_14, x_1); +x_20 = l_Lake_BuildTrace_mix(x_2, x_19); +x_21 = l_Lake_BuildTrace_mix(x_18, x_20); +x_22 = lean_ctor_get(x_3, 8); +lean_inc(x_22); +x_23 = l_System_FilePath_join(x_4, x_22); +x_24 = lean_ctor_get(x_3, 9); +lean_inc(x_24); +lean_inc(x_23); +x_25 = l_System_FilePath_join(x_23, x_24); +x_26 = l_Lake_Module_recBuildLean___lambda__3___closed__1; +lean_inc(x_5); +x_27 = l_Lean_modToFilePath(x_25, x_5, x_26); +x_28 = lean_ctor_get(x_14, 1); +lean_inc(x_28); +lean_dec(x_14); +x_29 = 3; +lean_inc(x_15); +lean_inc_n(x_6, 2); +x_30 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1(x_6, x_5, x_7, x_8, x_3, x_9, x_10, x_11, x_12, x_13, x_23, x_25, x_6, x_21, x_27, x_29, x_28, x_15, x_16, x_17); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +if (lean_obj_tag(x_31) == 0) +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +x_33 = lean_unbox(x_32); +lean_dec(x_32); +if (x_33 == 0) +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_31); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; +x_35 = lean_ctor_get(x_31, 1); +x_36 = lean_ctor_get(x_31, 0); +lean_dec(x_36); +x_37 = lean_ctor_get(x_30, 1); +lean_inc(x_37); +lean_dec(x_30); +x_38 = !lean_is_exclusive(x_35); +if (x_38 == 0) +{ +lean_object* x_39; lean_object* x_40; +x_39 = lean_ctor_get(x_35, 0); +x_40 = l_Lake_Module_cacheOutputHashes(x_6, x_37); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_free_object(x_31); +x_41 = lean_ctor_get(x_40, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_40, 1); +lean_inc(x_42); +lean_dec(x_40); +x_43 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_41, x_15, x_35, x_42); +lean_dec(x_15); +lean_dec(x_41); +return x_43; +} +else +{ +uint8_t x_44; +lean_dec(x_15); +lean_dec(x_1); +x_44 = !lean_is_exclusive(x_40); +if (x_44 == 0) +{ +lean_object* x_45; lean_object* x_46; uint8_t x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_45 = lean_ctor_get(x_40, 0); +x_46 = lean_io_error_to_string(x_45); +x_47 = 3; +x_48 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set_uint8(x_48, sizeof(void*)*1, x_47); +x_49 = lean_array_get_size(x_39); +x_50 = lean_array_push(x_39, x_48); +lean_ctor_set(x_35, 0, x_50); +lean_ctor_set_tag(x_31, 1); +lean_ctor_set(x_31, 0, x_49); +lean_ctor_set_tag(x_40, 0); +lean_ctor_set(x_40, 0, x_31); +return x_40; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_51 = lean_ctor_get(x_40, 0); +x_52 = lean_ctor_get(x_40, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_40); +x_53 = lean_io_error_to_string(x_51); +x_54 = 3; +x_55 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set_uint8(x_55, sizeof(void*)*1, x_54); +x_56 = lean_array_get_size(x_39); +x_57 = lean_array_push(x_39, x_55); +lean_ctor_set(x_35, 0, x_57); +lean_ctor_set_tag(x_31, 1); +lean_ctor_set(x_31, 0, x_56); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_31); +lean_ctor_set(x_58, 1, x_52); +return x_58; +} +} +} +else +{ +lean_object* x_59; uint8_t x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_35, 0); +x_60 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_59); +lean_dec(x_35); +x_61 = l_Lake_Module_cacheOutputHashes(x_6, x_37); +if (lean_obj_tag(x_61) == 0) +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +lean_free_object(x_31); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_61, 1); +lean_inc(x_63); +lean_dec(x_61); +x_64 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_64, 0, x_59); +lean_ctor_set_uint8(x_64, sizeof(void*)*1, x_60); +x_65 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_62, x_15, x_64, x_63); +lean_dec(x_15); +lean_dec(x_62); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +lean_dec(x_15); +lean_dec(x_1); +x_66 = lean_ctor_get(x_61, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_61, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_61)) { + lean_ctor_release(x_61, 0); + lean_ctor_release(x_61, 1); + x_68 = x_61; +} else { + lean_dec_ref(x_61); + x_68 = lean_box(0); +} +x_69 = lean_io_error_to_string(x_66); +x_70 = 3; +x_71 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_71, 0, x_69); +lean_ctor_set_uint8(x_71, sizeof(void*)*1, x_70); +x_72 = lean_array_get_size(x_59); +x_73 = lean_array_push(x_59, x_71); +x_74 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set_uint8(x_74, sizeof(void*)*1, x_60); +lean_ctor_set_tag(x_31, 1); +lean_ctor_set(x_31, 1, x_74); +lean_ctor_set(x_31, 0, x_72); +if (lean_is_scalar(x_68)) { + x_75 = lean_alloc_ctor(0, 2, 0); +} else { + x_75 = x_68; + lean_ctor_set_tag(x_75, 0); +} +lean_ctor_set(x_75, 0, x_31); +lean_ctor_set(x_75, 1, x_67); +return x_75; +} +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; lean_object* x_80; lean_object* x_81; +x_76 = lean_ctor_get(x_31, 1); +lean_inc(x_76); +lean_dec(x_31); +x_77 = lean_ctor_get(x_30, 1); +lean_inc(x_77); +lean_dec(x_30); +x_78 = lean_ctor_get(x_76, 0); +lean_inc(x_78); +x_79 = lean_ctor_get_uint8(x_76, sizeof(void*)*1); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + x_80 = x_76; +} else { + lean_dec_ref(x_76); + x_80 = lean_box(0); +} +x_81 = l_Lake_Module_cacheOutputHashes(x_6, x_77); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_82 = lean_ctor_get(x_81, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_81, 1); +lean_inc(x_83); +lean_dec(x_81); +if (lean_is_scalar(x_80)) { + x_84 = lean_alloc_ctor(0, 1, 1); +} else { + x_84 = x_80; +} +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set_uint8(x_84, sizeof(void*)*1, x_79); +x_85 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_82, x_15, x_84, x_83); +lean_dec(x_15); +lean_dec(x_82); +return x_85; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_15); +lean_dec(x_1); +x_86 = lean_ctor_get(x_81, 0); +lean_inc(x_86); +x_87 = lean_ctor_get(x_81, 1); +lean_inc(x_87); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_88 = x_81; +} else { + lean_dec_ref(x_81); + x_88 = lean_box(0); +} +x_89 = lean_io_error_to_string(x_86); +x_90 = 3; +x_91 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set_uint8(x_91, sizeof(void*)*1, x_90); +x_92 = lean_array_get_size(x_78); +x_93 = lean_array_push(x_78, x_91); +if (lean_is_scalar(x_80)) { + x_94 = lean_alloc_ctor(0, 1, 1); +} else { + x_94 = x_80; +} +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set_uint8(x_94, sizeof(void*)*1, x_79); +x_95 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_94); +if (lean_is_scalar(x_88)) { + x_96 = lean_alloc_ctor(0, 2, 0); +} else { + x_96 = x_88; + lean_ctor_set_tag(x_96, 0); +} +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_87); +return x_96; +} +} +} +else +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_15, 0); +lean_inc(x_97); +x_98 = lean_ctor_get_uint8(x_97, sizeof(void*)*1 + 1); +lean_dec(x_97); +if (x_98 == 0) +{ +uint8_t x_99; +x_99 = !lean_is_exclusive(x_31); +if (x_99 == 0) +{ +lean_object* x_100; lean_object* x_101; lean_object* x_102; uint8_t x_103; +x_100 = lean_ctor_get(x_31, 1); +x_101 = lean_ctor_get(x_31, 0); +lean_dec(x_101); +x_102 = lean_ctor_get(x_30, 1); +lean_inc(x_102); +lean_dec(x_30); +x_103 = !lean_is_exclusive(x_100); +if (x_103 == 0) +{ +lean_object* x_104; lean_object* x_105; +x_104 = lean_ctor_get(x_100, 0); +x_105 = l_Lake_Module_cacheOutputHashes(x_6, x_102); +if (lean_obj_tag(x_105) == 0) +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_free_object(x_31); +x_106 = lean_ctor_get(x_105, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_105, 1); +lean_inc(x_107); +lean_dec(x_105); +x_108 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_106, x_15, x_100, x_107); +lean_dec(x_15); +lean_dec(x_106); +return x_108; +} +else +{ +uint8_t x_109; +lean_dec(x_15); +lean_dec(x_1); +x_109 = !lean_is_exclusive(x_105); +if (x_109 == 0) +{ +lean_object* x_110; lean_object* x_111; uint8_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; +x_110 = lean_ctor_get(x_105, 0); +x_111 = lean_io_error_to_string(x_110); +x_112 = 3; +x_113 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_113, 0, x_111); +lean_ctor_set_uint8(x_113, sizeof(void*)*1, x_112); +x_114 = lean_array_get_size(x_104); +x_115 = lean_array_push(x_104, x_113); +lean_ctor_set(x_100, 0, x_115); +lean_ctor_set_tag(x_31, 1); +lean_ctor_set(x_31, 0, x_114); +lean_ctor_set_tag(x_105, 0); +lean_ctor_set(x_105, 0, x_31); +return x_105; +} +else +{ +lean_object* x_116; lean_object* x_117; lean_object* x_118; uint8_t x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_116 = lean_ctor_get(x_105, 0); +x_117 = lean_ctor_get(x_105, 1); +lean_inc(x_117); +lean_inc(x_116); +lean_dec(x_105); +x_118 = lean_io_error_to_string(x_116); +x_119 = 3; +x_120 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_120, 0, x_118); +lean_ctor_set_uint8(x_120, sizeof(void*)*1, x_119); +x_121 = lean_array_get_size(x_104); +x_122 = lean_array_push(x_104, x_120); +lean_ctor_set(x_100, 0, x_122); +lean_ctor_set_tag(x_31, 1); +lean_ctor_set(x_31, 0, x_121); +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_31); +lean_ctor_set(x_123, 1, x_117); +return x_123; +} +} +} +else +{ +lean_object* x_124; uint8_t x_125; lean_object* x_126; +x_124 = lean_ctor_get(x_100, 0); +x_125 = lean_ctor_get_uint8(x_100, sizeof(void*)*1); +lean_inc(x_124); +lean_dec(x_100); +x_126 = l_Lake_Module_cacheOutputHashes(x_6, x_102); +if (lean_obj_tag(x_126) == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_free_object(x_31); +x_127 = lean_ctor_get(x_126, 0); +lean_inc(x_127); +x_128 = lean_ctor_get(x_126, 1); +lean_inc(x_128); +lean_dec(x_126); +x_129 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_129, 0, x_124); +lean_ctor_set_uint8(x_129, sizeof(void*)*1, x_125); +x_130 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_127, x_15, x_129, x_128); +lean_dec(x_15); +lean_dec(x_127); +return x_130; +} +else +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; uint8_t x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_15); +lean_dec(x_1); +x_131 = lean_ctor_get(x_126, 0); +lean_inc(x_131); +x_132 = lean_ctor_get(x_126, 1); +lean_inc(x_132); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_133 = x_126; +} else { + lean_dec_ref(x_126); + x_133 = lean_box(0); +} +x_134 = lean_io_error_to_string(x_131); +x_135 = 3; +x_136 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_136, 0, x_134); +lean_ctor_set_uint8(x_136, sizeof(void*)*1, x_135); +x_137 = lean_array_get_size(x_124); +x_138 = lean_array_push(x_124, x_136); +x_139 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set_uint8(x_139, sizeof(void*)*1, x_125); +lean_ctor_set_tag(x_31, 1); +lean_ctor_set(x_31, 1, x_139); +lean_ctor_set(x_31, 0, x_137); +if (lean_is_scalar(x_133)) { + x_140 = lean_alloc_ctor(0, 2, 0); +} else { + x_140 = x_133; + lean_ctor_set_tag(x_140, 0); +} +lean_ctor_set(x_140, 0, x_31); +lean_ctor_set(x_140, 1, x_132); +return x_140; +} +} +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; uint8_t x_144; lean_object* x_145; lean_object* x_146; +x_141 = lean_ctor_get(x_31, 1); +lean_inc(x_141); +lean_dec(x_31); +x_142 = lean_ctor_get(x_30, 1); +lean_inc(x_142); +lean_dec(x_30); +x_143 = lean_ctor_get(x_141, 0); +lean_inc(x_143); +x_144 = lean_ctor_get_uint8(x_141, sizeof(void*)*1); +if (lean_is_exclusive(x_141)) { + lean_ctor_release(x_141, 0); + x_145 = x_141; +} else { + lean_dec_ref(x_141); + x_145 = lean_box(0); +} +x_146 = l_Lake_Module_cacheOutputHashes(x_6, x_142); +if (lean_obj_tag(x_146) == 0) +{ +lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_147 = lean_ctor_get(x_146, 0); +lean_inc(x_147); +x_148 = lean_ctor_get(x_146, 1); +lean_inc(x_148); +lean_dec(x_146); +if (lean_is_scalar(x_145)) { + x_149 = lean_alloc_ctor(0, 1, 1); +} else { + x_149 = x_145; +} +lean_ctor_set(x_149, 0, x_143); +lean_ctor_set_uint8(x_149, sizeof(void*)*1, x_144); +x_150 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_147, x_15, x_149, x_148); +lean_dec(x_15); +lean_dec(x_147); +return x_150; +} +else +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; +lean_dec(x_15); +lean_dec(x_1); +x_151 = lean_ctor_get(x_146, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_146, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_146)) { + lean_ctor_release(x_146, 0); + lean_ctor_release(x_146, 1); + x_153 = x_146; +} else { + lean_dec_ref(x_146); + x_153 = lean_box(0); +} +x_154 = lean_io_error_to_string(x_151); +x_155 = 3; +x_156 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_156, 0, x_154); +lean_ctor_set_uint8(x_156, sizeof(void*)*1, x_155); +x_157 = lean_array_get_size(x_143); +x_158 = lean_array_push(x_143, x_156); +if (lean_is_scalar(x_145)) { + x_159 = lean_alloc_ctor(0, 1, 1); +} else { + x_159 = x_145; +} +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set_uint8(x_159, sizeof(void*)*1, x_144); +x_160 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_159); +if (lean_is_scalar(x_153)) { + x_161 = lean_alloc_ctor(0, 2, 0); +} else { + x_161 = x_153; + lean_ctor_set_tag(x_161, 0); +} +lean_ctor_set(x_161, 0, x_160); +lean_ctor_set(x_161, 1, x_152); +return x_161; +} +} +} +else +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +lean_dec(x_6); +x_162 = lean_ctor_get(x_30, 1); +lean_inc(x_162); +lean_dec(x_30); +x_163 = lean_ctor_get(x_31, 1); +lean_inc(x_163); +lean_dec(x_31); +x_164 = lean_box(0); +x_165 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_164, x_15, x_163, x_162); +lean_dec(x_15); +return x_165; +} +} +} +else +{ +uint8_t x_166; +lean_dec(x_15); +lean_dec(x_6); +lean_dec(x_1); +x_166 = !lean_is_exclusive(x_30); +if (x_166 == 0) +{ +lean_object* x_167; uint8_t x_168; +x_167 = lean_ctor_get(x_30, 0); +lean_dec(x_167); +x_168 = !lean_is_exclusive(x_31); +if (x_168 == 0) +{ +return x_30; +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; +x_169 = lean_ctor_get(x_31, 0); +x_170 = lean_ctor_get(x_31, 1); +lean_inc(x_170); +lean_inc(x_169); +lean_dec(x_31); +x_171 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_171, 0, x_169); +lean_ctor_set(x_171, 1, x_170); +lean_ctor_set(x_30, 0, x_171); +return x_30; +} +} +else +{ +lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; +x_172 = lean_ctor_get(x_30, 1); +lean_inc(x_172); +lean_dec(x_30); +x_173 = lean_ctor_get(x_31, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_31, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_175 = x_31; +} else { + lean_dec_ref(x_31); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_175)) { + x_176 = lean_alloc_ctor(1, 2, 0); +} else { + x_176 = x_175; +} +lean_ctor_set(x_176, 0, x_173); +lean_ctor_set(x_176, 1, x_174); +x_177 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_177, 0, x_176); +lean_ctor_set(x_177, 1, x_172); +return x_177; +} +} +} +else +{ +uint8_t x_178; +lean_dec(x_15); +lean_dec(x_6); +lean_dec(x_1); +x_178 = !lean_is_exclusive(x_30); +if (x_178 == 0) +{ +return x_30; +} +else +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_179 = lean_ctor_get(x_30, 0); +x_180 = lean_ctor_get(x_30, 1); +lean_inc(x_180); +lean_inc(x_179); +lean_dec(x_30); +x_181 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_181, 0, x_179); +lean_ctor_set(x_181, 1, x_180); +return x_181; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_4); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +static lean_object* _init_l_Lake_Module_recBuildLean___lambda__5___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout/stderr:\n", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_4, 1); +lean_inc(x_8); +lean_dec(x_4); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = !lean_is_exclusive(x_7); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; size_t x_19; size_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; size_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint64_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get(x_7, 1); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_14, 2); +lean_inc(x_15); +x_16 = lean_ctor_get(x_15, 1); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +x_18 = lean_array_get_size(x_17); +x_19 = lean_usize_of_nat(x_18); +lean_dec(x_18); +x_20 = 0; +x_21 = l_Array_mapMUnsafe_map___at_Lake_Package_moreLeanArgs___spec__1(x_19, x_20, x_17); +x_22 = lean_ctor_get(x_16, 1); +lean_inc(x_22); +x_23 = l_Array_append___rarg(x_21, x_22); +lean_dec(x_22); +x_24 = lean_ctor_get(x_13, 1); +lean_inc(x_24); +lean_dec(x_13); +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_25, 0); +lean_inc(x_26); +x_27 = lean_array_get_size(x_26); +x_28 = lean_usize_of_nat(x_27); +lean_dec(x_27); +x_29 = l_Array_mapMUnsafe_map___at_Lake_Package_moreLeanArgs___spec__1(x_28, x_20, x_26); +x_30 = l_Array_append___rarg(x_23, x_29); +lean_dec(x_29); +x_31 = lean_ctor_get(x_25, 1); +lean_inc(x_31); +x_32 = l_Array_append___rarg(x_30, x_31); +lean_dec(x_31); +x_33 = l_Lake_computeArrayHash___at_Lake_buildO___spec__1(x_32); +x_34 = l_Lake_Module_recBuildDeps___lambda__1___closed__2; +x_35 = lean_box_uint64(x_33); +lean_ctor_set(x_7, 1, x_34); +lean_ctor_set(x_7, 0, x_35); +x_36 = lean_ctor_get(x_14, 0); +lean_inc(x_36); +lean_dec(x_14); +x_37 = lean_ctor_get(x_15, 7); +lean_inc(x_37); +lean_inc(x_36); +x_38 = l_System_FilePath_join(x_36, x_37); +x_39 = lean_ctor_get(x_24, 2); +lean_inc(x_39); +lean_dec(x_24); +x_40 = l_System_FilePath_join(x_38, x_39); +x_41 = l_Lake_Module_recParseImports___closed__1; +lean_inc(x_2); +x_42 = l_Lean_modToFilePath(x_40, x_2, x_41); +lean_inc(x_42); +x_43 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLean___lambda__1___boxed), 4, 1); +lean_closure_set(x_43, 0, x_42); +x_44 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLean___lambda__3___boxed), 17, 13); +lean_closure_set(x_44, 0, x_9); +lean_closure_set(x_44, 1, x_7); +lean_closure_set(x_44, 2, x_15); +lean_closure_set(x_44, 3, x_36); +lean_closure_set(x_44, 4, x_2); +lean_closure_set(x_44, 5, x_1); +lean_closure_set(x_44, 6, x_11); +lean_closure_set(x_44, 7, x_12); +lean_closure_set(x_44, 8, x_16); +lean_closure_set(x_44, 9, x_25); +lean_closure_set(x_44, 10, x_32); +lean_closure_set(x_44, 11, x_40); +lean_closure_set(x_44, 12, x_42); +x_45 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_45, 0, x_43); +lean_closure_set(x_45, 1, x_44); +x_46 = 1; +lean_inc(x_3); +x_47 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4(x_45, x_46, x_3, x_8, x_5); +if (lean_obj_tag(x_47) == 0) +{ +lean_object* x_48; +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_47, 1); +lean_inc(x_50); +lean_dec(x_47); +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = lean_ctor_get(x_49, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_49, 1); +lean_inc(x_53); +lean_dec(x_49); +x_54 = l_String_isEmpty(x_52); +if (x_54 == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; lean_object* x_60; uint8_t x_61; +x_55 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_56 = lean_string_append(x_55, x_52); +lean_dec(x_52); +x_57 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_58 = lean_string_append(x_56, x_57); +x_59 = 1; +x_60 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set_uint8(x_60, sizeof(void*)*1, x_59); +x_61 = !lean_is_exclusive(x_51); +if (x_61 == 0) +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_62 = lean_ctor_get(x_51, 0); +x_63 = lean_array_push(x_62, x_60); +lean_ctor_set(x_51, 0, x_63); +x_64 = lean_box(0); +x_65 = l_Lake_Module_recBuildLean___lambda__4(x_53, x_64, x_3, x_51, x_50); +lean_dec(x_3); +return x_65; +} +else +{ +lean_object* x_66; uint8_t x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_66 = lean_ctor_get(x_51, 0); +x_67 = lean_ctor_get_uint8(x_51, sizeof(void*)*1); +lean_inc(x_66); +lean_dec(x_51); +x_68 = lean_array_push(x_66, x_60); +x_69 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set_uint8(x_69, sizeof(void*)*1, x_67); +x_70 = lean_box(0); +x_71 = l_Lake_Module_recBuildLean___lambda__4(x_53, x_70, x_3, x_69, x_50); +lean_dec(x_3); +return x_71; +} +} +else +{ +lean_object* x_72; lean_object* x_73; +lean_dec(x_52); +x_72 = lean_box(0); +x_73 = l_Lake_Module_recBuildLean___lambda__4(x_53, x_72, x_3, x_51, x_50); +lean_dec(x_3); +return x_73; +} +} +else +{ +uint8_t x_74; +lean_dec(x_3); +x_74 = !lean_is_exclusive(x_47); +if (x_74 == 0) +{ +lean_object* x_75; uint8_t x_76; +x_75 = lean_ctor_get(x_47, 0); +lean_dec(x_75); +x_76 = !lean_is_exclusive(x_48); +if (x_76 == 0) +{ +return x_47; +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_77 = lean_ctor_get(x_48, 0); +x_78 = lean_ctor_get(x_48, 1); +lean_inc(x_78); +lean_inc(x_77); +lean_dec(x_48); +x_79 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_79, 0, x_77); +lean_ctor_set(x_79, 1, x_78); +lean_ctor_set(x_47, 0, x_79); +return x_47; +} +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_80 = lean_ctor_get(x_47, 1); +lean_inc(x_80); +lean_dec(x_47); +x_81 = lean_ctor_get(x_48, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_48, 1); +lean_inc(x_82); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_83 = x_48; +} else { + lean_dec_ref(x_48); + x_83 = lean_box(0); +} +if (lean_is_scalar(x_83)) { + x_84 = lean_alloc_ctor(1, 2, 0); +} else { + x_84 = x_83; +} +lean_ctor_set(x_84, 0, x_81); +lean_ctor_set(x_84, 1, x_82); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_80); +return x_85; +} +} +} +else +{ +uint8_t x_86; +lean_dec(x_3); +x_86 = !lean_is_exclusive(x_47); +if (x_86 == 0) +{ +return x_47; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_47, 0); +x_88 = lean_ctor_get(x_47, 1); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_47); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +return x_89; +} +} +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; size_t x_98; size_t 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; size_t x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; uint64_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; +x_90 = lean_ctor_get(x_7, 0); +x_91 = lean_ctor_get(x_7, 1); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_7); +x_92 = lean_ctor_get(x_1, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_92, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_93, 2); +lean_inc(x_94); +x_95 = lean_ctor_get(x_94, 1); +lean_inc(x_95); +x_96 = lean_ctor_get(x_95, 0); +lean_inc(x_96); +x_97 = lean_array_get_size(x_96); +x_98 = lean_usize_of_nat(x_97); +lean_dec(x_97); +x_99 = 0; +x_100 = l_Array_mapMUnsafe_map___at_Lake_Package_moreLeanArgs___spec__1(x_98, x_99, x_96); +x_101 = lean_ctor_get(x_95, 1); +lean_inc(x_101); +x_102 = l_Array_append___rarg(x_100, x_101); +lean_dec(x_101); +x_103 = lean_ctor_get(x_92, 1); +lean_inc(x_103); +lean_dec(x_92); +x_104 = lean_ctor_get(x_103, 0); +lean_inc(x_104); +x_105 = lean_ctor_get(x_104, 0); +lean_inc(x_105); +x_106 = lean_array_get_size(x_105); +x_107 = lean_usize_of_nat(x_106); +lean_dec(x_106); +x_108 = l_Array_mapMUnsafe_map___at_Lake_Package_moreLeanArgs___spec__1(x_107, x_99, x_105); +x_109 = l_Array_append___rarg(x_102, x_108); +lean_dec(x_108); +x_110 = lean_ctor_get(x_104, 1); +lean_inc(x_110); +x_111 = l_Array_append___rarg(x_109, x_110); +lean_dec(x_110); +x_112 = l_Lake_computeArrayHash___at_Lake_buildO___spec__1(x_111); +x_113 = l_Lake_Module_recBuildDeps___lambda__1___closed__2; +x_114 = lean_box_uint64(x_112); +x_115 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_115, 0, x_114); +lean_ctor_set(x_115, 1, x_113); +x_116 = lean_ctor_get(x_93, 0); +lean_inc(x_116); +lean_dec(x_93); +x_117 = lean_ctor_get(x_94, 7); +lean_inc(x_117); +lean_inc(x_116); +x_118 = l_System_FilePath_join(x_116, x_117); +x_119 = lean_ctor_get(x_103, 2); +lean_inc(x_119); +lean_dec(x_103); +x_120 = l_System_FilePath_join(x_118, x_119); +x_121 = l_Lake_Module_recParseImports___closed__1; +lean_inc(x_2); +x_122 = l_Lean_modToFilePath(x_120, x_2, x_121); +lean_inc(x_122); +x_123 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLean___lambda__1___boxed), 4, 1); +lean_closure_set(x_123, 0, x_122); +x_124 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLean___lambda__3___boxed), 17, 13); +lean_closure_set(x_124, 0, x_9); +lean_closure_set(x_124, 1, x_115); +lean_closure_set(x_124, 2, x_94); +lean_closure_set(x_124, 3, x_116); +lean_closure_set(x_124, 4, x_2); +lean_closure_set(x_124, 5, x_1); +lean_closure_set(x_124, 6, x_90); +lean_closure_set(x_124, 7, x_91); +lean_closure_set(x_124, 8, x_95); +lean_closure_set(x_124, 9, x_104); +lean_closure_set(x_124, 10, x_111); +lean_closure_set(x_124, 11, x_120); +lean_closure_set(x_124, 12, x_122); +x_125 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_125, 0, x_123); +lean_closure_set(x_125, 1, x_124); +x_126 = 1; +lean_inc(x_3); +x_127 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4(x_125, x_126, x_3, x_8, x_5); +if (lean_obj_tag(x_127) == 0) +{ +lean_object* x_128; +x_128 = lean_ctor_get(x_127, 0); +lean_inc(x_128); +if (lean_obj_tag(x_128) == 0) +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; +x_129 = lean_ctor_get(x_128, 0); +lean_inc(x_129); +x_130 = lean_ctor_get(x_127, 1); +lean_inc(x_130); +lean_dec(x_127); +x_131 = lean_ctor_get(x_128, 1); +lean_inc(x_131); +lean_dec(x_128); +x_132 = lean_ctor_get(x_129, 0); +lean_inc(x_132); +x_133 = lean_ctor_get(x_129, 1); +lean_inc(x_133); +lean_dec(x_129); +x_134 = l_String_isEmpty(x_132); +if (x_134 == 0) +{ +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; lean_object* x_140; lean_object* x_141; uint8_t x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_135 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_136 = lean_string_append(x_135, x_132); +lean_dec(x_132); +x_137 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_138 = lean_string_append(x_136, x_137); +x_139 = 1; +x_140 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_140, 0, x_138); +lean_ctor_set_uint8(x_140, sizeof(void*)*1, x_139); +x_141 = lean_ctor_get(x_131, 0); +lean_inc(x_141); +x_142 = lean_ctor_get_uint8(x_131, sizeof(void*)*1); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + x_143 = x_131; +} else { + lean_dec_ref(x_131); + x_143 = lean_box(0); +} +x_144 = lean_array_push(x_141, x_140); +if (lean_is_scalar(x_143)) { + x_145 = lean_alloc_ctor(0, 1, 1); +} else { + x_145 = x_143; +} +lean_ctor_set(x_145, 0, x_144); +lean_ctor_set_uint8(x_145, sizeof(void*)*1, x_142); +x_146 = lean_box(0); +x_147 = l_Lake_Module_recBuildLean___lambda__4(x_133, x_146, x_3, x_145, x_130); +lean_dec(x_3); +return x_147; +} +else +{ +lean_object* x_148; lean_object* x_149; +lean_dec(x_132); +x_148 = lean_box(0); +x_149 = l_Lake_Module_recBuildLean___lambda__4(x_133, x_148, x_3, x_131, x_130); +lean_dec(x_3); +return x_149; +} +} +else +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_3); +x_150 = lean_ctor_get(x_127, 1); +lean_inc(x_150); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + lean_ctor_release(x_127, 1); + x_151 = x_127; +} else { + lean_dec_ref(x_127); + x_151 = lean_box(0); +} +x_152 = lean_ctor_get(x_128, 0); +lean_inc(x_152); +x_153 = lean_ctor_get(x_128, 1); +lean_inc(x_153); +if (lean_is_exclusive(x_128)) { + lean_ctor_release(x_128, 0); + lean_ctor_release(x_128, 1); + x_154 = x_128; +} else { + lean_dec_ref(x_128); + x_154 = lean_box(0); +} +if (lean_is_scalar(x_154)) { + x_155 = lean_alloc_ctor(1, 2, 0); +} else { + x_155 = x_154; +} +lean_ctor_set(x_155, 0, x_152); +lean_ctor_set(x_155, 1, x_153); +if (lean_is_scalar(x_151)) { + x_156 = lean_alloc_ctor(0, 2, 0); +} else { + x_156 = x_151; +} +lean_ctor_set(x_156, 0, x_155); +lean_ctor_set(x_156, 1, x_150); +return x_156; +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_3); +x_157 = lean_ctor_get(x_127, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_127, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + lean_ctor_release(x_127, 1); + x_159 = x_127; +} else { + lean_dec_ref(x_127); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +} +else +{ +uint8_t x_161; +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_161 = !lean_is_exclusive(x_4); +if (x_161 == 0) +{ +lean_object* x_162; +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_4); +lean_ctor_set(x_162, 1, x_5); +return x_162; +} +else +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; +x_163 = lean_ctor_get(x_4, 0); +x_164 = lean_ctor_get(x_4, 1); +lean_inc(x_164); +lean_inc(x_163); +lean_dec(x_4); +x_165 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_165, 0, x_163); +lean_ctor_set(x_165, 1, x_164); +x_166 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_166, 0, x_165); +lean_ctor_set(x_166, 1, x_5); +return x_166; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_3); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_3, 0); +x_12 = lean_ctor_get(x_3, 1); +x_13 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLean___lambda__5), 5, 3); +lean_closure_set(x_13, 0, x_1); +lean_closure_set(x_13, 1, x_2); +lean_closure_set(x_13, 2, x_6); +x_14 = l_Task_Priority_default; +x_15 = 0; +x_16 = lean_io_map_task(x_13, x_11, x_14, x_15, x_9); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_16); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_16, 0); +lean_ctor_set(x_3, 0, x_18); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_3); +lean_ctor_set(x_19, 1, x_7); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_8); +lean_ctor_set(x_16, 0, x_20); +return x_16; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_21 = lean_ctor_get(x_16, 0); +x_22 = lean_ctor_get(x_16, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_16); +lean_ctor_set(x_3, 0, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_3); +lean_ctor_set(x_23, 1, x_7); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_8); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_22); +return x_25; +} +} +else +{ +uint8_t x_26; +lean_free_object(x_3); +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +x_26 = !lean_is_exclusive(x_16); +if (x_26 == 0) +{ +return x_16; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_16, 0); +x_28 = lean_ctor_get(x_16, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_16); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +return x_29; +} +} +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; +x_30 = lean_ctor_get(x_3, 0); +x_31 = lean_ctor_get(x_3, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_3); +x_32 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLean___lambda__5), 5, 3); +lean_closure_set(x_32, 0, x_1); +lean_closure_set(x_32, 1, x_2); +lean_closure_set(x_32, 2, x_6); +x_33 = l_Task_Priority_default; +x_34 = 0; +x_35 = lean_io_map_task(x_32, x_30, x_33, x_34, x_9); +if (lean_obj_tag(x_35) == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_36 = lean_ctor_get(x_35, 0); +lean_inc(x_36); +x_37 = lean_ctor_get(x_35, 1); +lean_inc(x_37); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_38 = x_35; +} else { + lean_dec_ref(x_35); + x_38 = lean_box(0); +} +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_36); +lean_ctor_set(x_39, 1, x_31); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_7); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_8); +if (lean_is_scalar(x_38)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_38; +} +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_dec(x_31); +lean_dec(x_8); +lean_dec(x_7); +x_43 = lean_ctor_get(x_35, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_35, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_45 = x_35; +} else { + lean_dec_ref(x_35); + x_45 = lean_box(0); +} +if (lean_is_scalar(x_45)) { + x_46 = lean_alloc_ctor(1, 2, 0); +} else { + x_46 = x_45; +} +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_44); +return x_46; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = 1; +lean_inc(x_8); +x_10 = l_Lean_Name_toString(x_8, x_9); +x_11 = l_Lake_Module_depsFacetConfig___closed__4; +lean_inc(x_1); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_1); +lean_ctor_set(x_12, 1, x_11); +x_13 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_13, 0, x_12); +lean_closure_set(x_13, 1, lean_box(0)); +x_14 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLean___lambda__6___boxed), 9, 2); +lean_closure_set(x_14, 0, x_1); +lean_closure_set(x_14, 1, x_8); +x_15 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 2); +lean_closure_set(x_15, 0, x_13); +lean_closure_set(x_15, 1, x_14); +x_16 = l_Lake_withRegisterJob___rarg(x_10, x_15, x_2, x_3, x_4, x_5, x_6, x_7); +return x_16; +} +} +LEAN_EXPORT lean_object* l_Lake_checkHashUpToDate___at_Lake_Module_recBuildLean___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_checkHashUpToDate___at_Lake_Module_recBuildLean___spec__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_5); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__1(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16) { +_start: +{ +lean_object* x_17; +x_17 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16); +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_1); +return x_17; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; lean_object* x_11; +x_10 = lean_unbox(x_5); +lean_dec(x_5); +x_11 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3(x_1, x_2, x_3, x_4, x_10, x_6, x_7, x_8, x_9); +lean_dec(x_6); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___boxed(lean_object** _args) { +lean_object* x_1 = _args[0]; +lean_object* x_2 = _args[1]; +lean_object* x_3 = _args[2]; +lean_object* x_4 = _args[3]; +lean_object* x_5 = _args[4]; +lean_object* x_6 = _args[5]; +lean_object* x_7 = _args[6]; +lean_object* x_8 = _args[7]; +lean_object* x_9 = _args[8]; +lean_object* x_10 = _args[9]; +lean_object* x_11 = _args[10]; +lean_object* x_12 = _args[11]; +lean_object* x_13 = _args[12]; +lean_object* x_14 = _args[13]; +lean_object* x_15 = _args[14]; +lean_object* x_16 = _args[15]; +lean_object* x_17 = _args[16]; +lean_object* x_18 = _args[17]; +lean_object* x_19 = _args[18]; +lean_object* x_20 = _args[19]; +_start: +{ +uint8_t x_21; lean_object* x_22; +x_21 = lean_unbox(x_16); +lean_dec(x_16); +x_22 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_21, x_17, x_18, x_19, x_20); +return x_22; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Module_recBuildLean___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Module_recBuildLean___lambda__2(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__3___boxed(lean_object** _args) { +lean_object* x_1 = _args[0]; +lean_object* x_2 = _args[1]; +lean_object* x_3 = _args[2]; +lean_object* x_4 = _args[3]; +lean_object* x_5 = _args[4]; +lean_object* x_6 = _args[5]; +lean_object* x_7 = _args[6]; +lean_object* x_8 = _args[7]; +lean_object* x_9 = _args[8]; +lean_object* x_10 = _args[9]; +lean_object* x_11 = _args[10]; +lean_object* x_12 = _args[11]; +lean_object* x_13 = _args[12]; +lean_object* x_14 = _args[13]; +lean_object* x_15 = _args[14]; +lean_object* x_16 = _args[15]; +lean_object* x_17 = _args[16]; +_start: +{ +lean_object* x_18; +x_18 = l_Lake_Module_recBuildLean___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17); +return x_18; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Module_recBuildLean___lambda__4(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLean___lambda__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_Module_recBuildLean___lambda__6(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_5); +lean_dec(x_4); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_leanArtsFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Module_recBuildLean(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_leanArtsFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Module_leanArtsFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Module_leanArtsFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanArts", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_leanArtsFacetConfig___closed__3; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacetConfig___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_leanArtsFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacetConfig___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_leanArtsFacetConfig___closed__5; +x_2 = l_Lake_Module_leanArtsFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_leanArtsFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_leanArtsFacetConfig___closed__6; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_7 = l_Lake_BuildTrace_mix(x_3, x_1); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_2); +lean_ctor_set(x_8, 1, x_7); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_5); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_6); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_3, 1); +lean_inc(x_6); +lean_dec(x_3); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 2); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_ctor_get(x_11, 8); +lean_inc(x_12); +x_13 = l_System_FilePath_join(x_10, x_12); +x_14 = lean_ctor_get(x_11, 9); +lean_inc(x_14); +lean_dec(x_11); +x_15 = l_System_FilePath_join(x_13, x_14); +x_16 = lean_ctor_get(x_1, 1); +lean_inc(x_16); +lean_dec(x_1); +x_17 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1; +x_18 = l_Lean_modToFilePath(x_15, x_16, x_17); +lean_dec(x_15); +lean_inc(x_18); +x_19 = lean_alloc_closure((void*)(l_Lake_fetchFileTrace___boxed), 4, 1); +lean_closure_set(x_19, 0, x_18); +x_20 = lean_alloc_closure((void*)(l_Lake_Module_oleanFacetConfig___elambda__1___lambda__1___boxed), 6, 2); +lean_closure_set(x_20, 0, x_7); +lean_closure_set(x_20, 1, x_18); +x_21 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_21, 0, x_19); +lean_closure_set(x_21, 1, x_20); +x_22 = 1; +lean_inc(x_2); +x_23 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_21, x_22, x_2, x_6, x_4); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; +x_24 = lean_ctor_get(x_23, 0); +lean_inc(x_24); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_23, 1); +lean_inc(x_26); +lean_dec(x_23); +x_27 = lean_ctor_get(x_24, 1); +lean_inc(x_27); +lean_dec(x_24); +x_28 = lean_ctor_get(x_25, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_25, 1); +lean_inc(x_29); +lean_dec(x_25); +x_30 = l_String_isEmpty(x_28); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; uint8_t x_37; +x_31 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_32 = lean_string_append(x_31, x_28); +lean_dec(x_28); +x_33 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_34 = lean_string_append(x_32, x_33); +x_35 = 1; +x_36 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set_uint8(x_36, sizeof(void*)*1, x_35); +x_37 = !lean_is_exclusive(x_27); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_27, 0); +x_39 = lean_array_push(x_38, x_36); +lean_ctor_set(x_27, 0, x_39); +x_40 = lean_box(0); +x_41 = l_Lake_Module_recBuildLean___lambda__4(x_29, x_40, x_2, x_27, x_26); +lean_dec(x_2); +return x_41; +} +else +{ +lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_42 = lean_ctor_get(x_27, 0); +x_43 = lean_ctor_get_uint8(x_27, sizeof(void*)*1); +lean_inc(x_42); +lean_dec(x_27); +x_44 = lean_array_push(x_42, x_36); +x_45 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set_uint8(x_45, sizeof(void*)*1, x_43); +x_46 = lean_box(0); +x_47 = l_Lake_Module_recBuildLean___lambda__4(x_29, x_46, x_2, x_45, x_26); +lean_dec(x_2); +return x_47; +} +} +else +{ +lean_object* x_48; lean_object* x_49; +lean_dec(x_28); +x_48 = lean_box(0); +x_49 = l_Lake_Module_recBuildLean___lambda__4(x_29, x_48, x_2, x_27, x_26); +lean_dec(x_2); +return x_49; +} +} +else +{ +uint8_t x_50; +lean_dec(x_2); +x_50 = !lean_is_exclusive(x_23); +if (x_50 == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_23, 0); +lean_dec(x_51); +x_52 = !lean_is_exclusive(x_24); +if (x_52 == 0) +{ +return x_23; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_24, 0); +x_54 = lean_ctor_get(x_24, 1); +lean_inc(x_54); +lean_inc(x_53); +lean_dec(x_24); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +lean_ctor_set(x_23, 0, x_55); +return x_23; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_56 = lean_ctor_get(x_23, 1); +lean_inc(x_56); +lean_dec(x_23); +x_57 = lean_ctor_get(x_24, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_24, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_59 = x_24; +} else { + lean_dec_ref(x_24); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_56); +return x_61; +} +} +} +else +{ +uint8_t x_62; +lean_dec(x_2); +x_62 = !lean_is_exclusive(x_23); +if (x_62 == 0) +{ +return x_23; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_23, 0); +x_64 = lean_ctor_get(x_23, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_23); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +uint8_t x_66; +lean_dec(x_2); +lean_dec(x_1); +x_66 = !lean_is_exclusive(x_3); +if (x_66 == 0) +{ +lean_object* x_67; +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_3); +lean_ctor_set(x_67, 1, x_4); +return x_67; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_68 = lean_ctor_get(x_3, 0); +x_69 = lean_ctor_get(x_3, 1); +lean_inc(x_69); +lean_inc(x_68); +lean_dec(x_3); +x_70 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_70, 0, x_68); +lean_ctor_set(x_70, 1, x_69); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_4); +return x_71; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Lake_Module_leanArtsFacetConfig___closed__4; +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +lean_inc(x_4); +x_10 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_dec(x_10); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_16 = lean_ctor_get(x_11, 1); +x_17 = lean_ctor_get(x_11, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_12); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_19 = lean_ctor_get(x_12, 1); +x_20 = lean_ctor_get(x_12, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_13); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_13, 0); +x_23 = lean_ctor_get(x_13, 1); +x_24 = lean_alloc_closure((void*)(l_Lake_Module_oleanFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_24, 0, x_1); +lean_closure_set(x_24, 1, x_4); +x_25 = l_Task_Priority_default; +x_26 = 0; +x_27 = lean_io_map_task(x_24, x_22, x_25, x_26, x_14); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; +x_29 = lean_ctor_get(x_27, 0); +lean_ctor_set(x_13, 0, x_29); +lean_ctor_set(x_27, 0, x_11); +return x_27; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_27, 0); +x_31 = lean_ctor_get(x_27, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_27); +lean_ctor_set(x_13, 0, x_30); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_11); +lean_ctor_set(x_32, 1, x_31); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_free_object(x_13); +lean_dec(x_23); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_33 = !lean_is_exclusive(x_27); +if (x_33 == 0) +{ +return x_27; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_27, 0); +x_35 = lean_ctor_get(x_27, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_27); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; +x_37 = lean_ctor_get(x_13, 0); +x_38 = lean_ctor_get(x_13, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_13); +x_39 = lean_alloc_closure((void*)(l_Lake_Module_oleanFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_39, 0, x_1); +lean_closure_set(x_39, 1, x_4); +x_40 = l_Task_Priority_default; +x_41 = 0; +x_42 = lean_io_map_task(x_39, x_37, x_40, x_41, x_14); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_38); +lean_ctor_set(x_12, 0, x_46); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_11); +lean_ctor_set(x_47, 1, x_44); +return x_47; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_dec(x_38); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_48 = lean_ctor_get(x_42, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_42, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_50 = x_42; +} else { + lean_dec_ref(x_42); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +return x_51; +} +} +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; +x_52 = lean_ctor_get(x_12, 1); +lean_inc(x_52); +lean_dec(x_12); +x_53 = lean_ctor_get(x_13, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_13, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_55 = x_13; +} else { + lean_dec_ref(x_13); + x_55 = lean_box(0); +} +x_56 = lean_alloc_closure((void*)(l_Lake_Module_oleanFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_56, 0, x_1); +lean_closure_set(x_56, 1, x_4); +x_57 = l_Task_Priority_default; +x_58 = 0; +x_59 = lean_io_map_task(x_56, x_53, x_57, x_58, x_14); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_60 = lean_ctor_get(x_59, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_59, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_62 = x_59; +} else { + lean_dec_ref(x_59); + x_62 = lean_box(0); +} +if (lean_is_scalar(x_55)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_55; +} +lean_ctor_set(x_63, 0, x_60); +lean_ctor_set(x_63, 1, x_54); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_52); +lean_ctor_set(x_11, 0, x_64); +if (lean_is_scalar(x_62)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_62; +} +lean_ctor_set(x_65, 0, x_11); +lean_ctor_set(x_65, 1, x_61); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_55); +lean_dec(x_54); +lean_dec(x_52); +lean_free_object(x_11); +lean_dec(x_16); +x_66 = lean_ctor_get(x_59, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_68 = x_59; +} else { + lean_dec_ref(x_59); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +return x_69; +} +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; +x_70 = lean_ctor_get(x_11, 1); +lean_inc(x_70); +lean_dec(x_11); +x_71 = lean_ctor_get(x_12, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_72 = x_12; +} else { + lean_dec_ref(x_12); + x_72 = lean_box(0); +} +x_73 = lean_ctor_get(x_13, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_13, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_75 = x_13; +} else { + lean_dec_ref(x_13); + x_75 = lean_box(0); +} +x_76 = lean_alloc_closure((void*)(l_Lake_Module_oleanFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_76, 0, x_1); +lean_closure_set(x_76, 1, x_4); +x_77 = l_Task_Priority_default; +x_78 = 0; +x_79 = lean_io_map_task(x_76, x_73, x_77, x_78, x_14); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_79, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_82 = x_79; +} else { + lean_dec_ref(x_79); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_75; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_74); +if (lean_is_scalar(x_72)) { + x_84 = lean_alloc_ctor(0, 2, 0); +} else { + x_84 = x_72; +} +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_71); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_70); +if (lean_is_scalar(x_82)) { + x_86 = lean_alloc_ctor(0, 2, 0); +} else { + x_86 = x_82; +} +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_81); +return x_86; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_72); +lean_dec(x_71); +lean_dec(x_70); +x_87 = lean_ctor_get(x_79, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_79, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_89 = x_79; +} else { + lean_dec_ref(x_79); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +uint8_t x_91; +lean_dec(x_4); +lean_dec(x_1); +x_91 = !lean_is_exclusive(x_10); +if (x_91 == 0) +{ +lean_object* x_92; uint8_t x_93; +x_92 = lean_ctor_get(x_10, 0); +lean_dec(x_92); +x_93 = !lean_is_exclusive(x_11); +if (x_93 == 0) +{ +lean_object* x_94; uint8_t x_95; +x_94 = lean_ctor_get(x_11, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_12); +if (x_95 == 0) +{ +return x_10; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_12, 0); +x_97 = lean_ctor_get(x_12, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_12); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +lean_ctor_set(x_11, 0, x_98); +return x_10; +} +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_99 = lean_ctor_get(x_11, 1); +lean_inc(x_99); +lean_dec(x_11); +x_100 = lean_ctor_get(x_12, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_12, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_102 = x_12; +} else { + lean_dec_ref(x_12); + x_102 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_103 = lean_alloc_ctor(1, 2, 0); +} else { + x_103 = x_102; +} +lean_ctor_set(x_103, 0, x_100); +lean_ctor_set(x_103, 1, x_101); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_99); +lean_ctor_set(x_10, 0, x_104); +return x_10; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_105 = lean_ctor_get(x_10, 1); +lean_inc(x_105); +lean_dec(x_10); +x_106 = lean_ctor_get(x_11, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_107 = x_11; +} else { + lean_dec_ref(x_11); + x_107 = lean_box(0); +} +x_108 = lean_ctor_get(x_12, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_12, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_110 = x_12; +} else { + lean_dec_ref(x_12); + x_110 = lean_box(0); +} +if (lean_is_scalar(x_110)) { + x_111 = lean_alloc_ctor(1, 2, 0); +} else { + x_111 = x_110; +} +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_109); +if (lean_is_scalar(x_107)) { + x_112 = lean_alloc_ctor(0, 2, 0); +} else { + x_112 = x_107; +} +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_106); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_105); +return x_113; +} +} +} +else +{ +uint8_t x_114; +lean_dec(x_4); +lean_dec(x_1); +x_114 = !lean_is_exclusive(x_10); +if (x_114 == 0) +{ +return x_10; +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_115 = lean_ctor_get(x_10, 0); +x_116 = lean_ctor_get(x_10, 1); +lean_inc(x_116); +lean_inc(x_115); +lean_dec(x_10); +x_117 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_117, 0, x_115); +lean_ctor_set(x_117, 1, x_116); +return x_117; +} +} +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_oleanFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_Module_oleanFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Module_oleanFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oleanFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Module_oleanFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_oleanFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_oleanFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oleanFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_oleanFacetConfig___closed__3; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oleanFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oleanFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oleanFacetConfig___elambda__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_Module_oleanFacetConfig___elambda__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_ileanFacetConfig___elambda__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_3, 1); +lean_inc(x_6); +lean_dec(x_3); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 2); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_ctor_get(x_11, 8); +lean_inc(x_12); +x_13 = l_System_FilePath_join(x_10, x_12); +x_14 = lean_ctor_get(x_11, 9); +lean_inc(x_14); +lean_dec(x_11); +x_15 = l_System_FilePath_join(x_13, x_14); +x_16 = lean_ctor_get(x_1, 1); +lean_inc(x_16); +lean_dec(x_1); +x_17 = l_Lake_Module_clearOutputHashes___closed__1; +x_18 = l_Lean_modToFilePath(x_15, x_16, x_17); +lean_dec(x_15); +lean_inc(x_18); +x_19 = lean_alloc_closure((void*)(l_Lake_fetchFileTrace___boxed), 4, 1); +lean_closure_set(x_19, 0, x_18); +x_20 = lean_alloc_closure((void*)(l_Lake_Module_oleanFacetConfig___elambda__1___lambda__1___boxed), 6, 2); +lean_closure_set(x_20, 0, x_7); +lean_closure_set(x_20, 1, x_18); +x_21 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_21, 0, x_19); +lean_closure_set(x_21, 1, x_20); +x_22 = 1; +lean_inc(x_2); +x_23 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_21, x_22, x_2, x_6, x_4); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; +x_24 = lean_ctor_get(x_23, 0); +lean_inc(x_24); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_23, 1); +lean_inc(x_26); +lean_dec(x_23); +x_27 = lean_ctor_get(x_24, 1); +lean_inc(x_27); +lean_dec(x_24); +x_28 = lean_ctor_get(x_25, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_25, 1); +lean_inc(x_29); +lean_dec(x_25); +x_30 = l_String_isEmpty(x_28); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; uint8_t x_37; +x_31 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_32 = lean_string_append(x_31, x_28); +lean_dec(x_28); +x_33 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_34 = lean_string_append(x_32, x_33); +x_35 = 1; +x_36 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set_uint8(x_36, sizeof(void*)*1, x_35); +x_37 = !lean_is_exclusive(x_27); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_38 = lean_ctor_get(x_27, 0); +x_39 = lean_array_push(x_38, x_36); +lean_ctor_set(x_27, 0, x_39); +x_40 = lean_box(0); +x_41 = l_Lake_Module_recBuildLean___lambda__4(x_29, x_40, x_2, x_27, x_26); +lean_dec(x_2); +return x_41; +} +else +{ +lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_42 = lean_ctor_get(x_27, 0); +x_43 = lean_ctor_get_uint8(x_27, sizeof(void*)*1); +lean_inc(x_42); +lean_dec(x_27); +x_44 = lean_array_push(x_42, x_36); +x_45 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set_uint8(x_45, sizeof(void*)*1, x_43); +x_46 = lean_box(0); +x_47 = l_Lake_Module_recBuildLean___lambda__4(x_29, x_46, x_2, x_45, x_26); +lean_dec(x_2); +return x_47; +} +} +else +{ +lean_object* x_48; lean_object* x_49; +lean_dec(x_28); +x_48 = lean_box(0); +x_49 = l_Lake_Module_recBuildLean___lambda__4(x_29, x_48, x_2, x_27, x_26); +lean_dec(x_2); +return x_49; +} +} +else +{ +uint8_t x_50; +lean_dec(x_2); +x_50 = !lean_is_exclusive(x_23); +if (x_50 == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_23, 0); +lean_dec(x_51); +x_52 = !lean_is_exclusive(x_24); +if (x_52 == 0) +{ +return x_23; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_24, 0); +x_54 = lean_ctor_get(x_24, 1); +lean_inc(x_54); +lean_inc(x_53); +lean_dec(x_24); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +lean_ctor_set(x_23, 0, x_55); +return x_23; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_56 = lean_ctor_get(x_23, 1); +lean_inc(x_56); +lean_dec(x_23); +x_57 = lean_ctor_get(x_24, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_24, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_59 = x_24; +} else { + lean_dec_ref(x_24); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_56); +return x_61; +} +} +} +else +{ +uint8_t x_62; +lean_dec(x_2); +x_62 = !lean_is_exclusive(x_23); +if (x_62 == 0) +{ +return x_23; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_23, 0); +x_64 = lean_ctor_get(x_23, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_23); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +uint8_t x_66; +lean_dec(x_2); +lean_dec(x_1); +x_66 = !lean_is_exclusive(x_3); +if (x_66 == 0) +{ +lean_object* x_67; +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_3); +lean_ctor_set(x_67, 1, x_4); +return x_67; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_68 = lean_ctor_get(x_3, 0); +x_69 = lean_ctor_get(x_3, 1); +lean_inc(x_69); +lean_inc(x_68); +lean_dec(x_3); +x_70 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_70, 0, x_68); +lean_ctor_set(x_70, 1, x_69); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_4); +return x_71; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_ileanFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Lake_Module_leanArtsFacetConfig___closed__4; +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +lean_inc(x_4); +x_10 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_dec(x_10); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_16 = lean_ctor_get(x_11, 1); +x_17 = lean_ctor_get(x_11, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_12); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_19 = lean_ctor_get(x_12, 1); +x_20 = lean_ctor_get(x_12, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_13); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_13, 0); +x_23 = lean_ctor_get(x_13, 1); +x_24 = lean_alloc_closure((void*)(l_Lake_Module_ileanFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_24, 0, x_1); +lean_closure_set(x_24, 1, x_4); +x_25 = l_Task_Priority_default; +x_26 = 0; +x_27 = lean_io_map_task(x_24, x_22, x_25, x_26, x_14); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; +x_29 = lean_ctor_get(x_27, 0); +lean_ctor_set(x_13, 0, x_29); +lean_ctor_set(x_27, 0, x_11); +return x_27; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_27, 0); +x_31 = lean_ctor_get(x_27, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_27); +lean_ctor_set(x_13, 0, x_30); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_11); +lean_ctor_set(x_32, 1, x_31); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_free_object(x_13); +lean_dec(x_23); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_33 = !lean_is_exclusive(x_27); +if (x_33 == 0) +{ +return x_27; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_27, 0); +x_35 = lean_ctor_get(x_27, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_27); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; +x_37 = lean_ctor_get(x_13, 0); +x_38 = lean_ctor_get(x_13, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_13); +x_39 = lean_alloc_closure((void*)(l_Lake_Module_ileanFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_39, 0, x_1); +lean_closure_set(x_39, 1, x_4); +x_40 = l_Task_Priority_default; +x_41 = 0; +x_42 = lean_io_map_task(x_39, x_37, x_40, x_41, x_14); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_38); +lean_ctor_set(x_12, 0, x_46); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_11); +lean_ctor_set(x_47, 1, x_44); +return x_47; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_dec(x_38); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_48 = lean_ctor_get(x_42, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_42, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_50 = x_42; +} else { + lean_dec_ref(x_42); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +return x_51; +} +} +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; +x_52 = lean_ctor_get(x_12, 1); +lean_inc(x_52); +lean_dec(x_12); +x_53 = lean_ctor_get(x_13, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_13, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_55 = x_13; +} else { + lean_dec_ref(x_13); + x_55 = lean_box(0); +} +x_56 = lean_alloc_closure((void*)(l_Lake_Module_ileanFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_56, 0, x_1); +lean_closure_set(x_56, 1, x_4); +x_57 = l_Task_Priority_default; +x_58 = 0; +x_59 = lean_io_map_task(x_56, x_53, x_57, x_58, x_14); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_60 = lean_ctor_get(x_59, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_59, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_62 = x_59; +} else { + lean_dec_ref(x_59); + x_62 = lean_box(0); +} +if (lean_is_scalar(x_55)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_55; +} +lean_ctor_set(x_63, 0, x_60); +lean_ctor_set(x_63, 1, x_54); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_52); +lean_ctor_set(x_11, 0, x_64); +if (lean_is_scalar(x_62)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_62; +} +lean_ctor_set(x_65, 0, x_11); +lean_ctor_set(x_65, 1, x_61); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_55); +lean_dec(x_54); +lean_dec(x_52); +lean_free_object(x_11); +lean_dec(x_16); +x_66 = lean_ctor_get(x_59, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_68 = x_59; +} else { + lean_dec_ref(x_59); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +return x_69; +} +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; +x_70 = lean_ctor_get(x_11, 1); +lean_inc(x_70); +lean_dec(x_11); +x_71 = lean_ctor_get(x_12, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_72 = x_12; +} else { + lean_dec_ref(x_12); + x_72 = lean_box(0); +} +x_73 = lean_ctor_get(x_13, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_13, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_75 = x_13; +} else { + lean_dec_ref(x_13); + x_75 = lean_box(0); +} +x_76 = lean_alloc_closure((void*)(l_Lake_Module_ileanFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_76, 0, x_1); +lean_closure_set(x_76, 1, x_4); +x_77 = l_Task_Priority_default; +x_78 = 0; +x_79 = lean_io_map_task(x_76, x_73, x_77, x_78, x_14); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_79, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_82 = x_79; +} else { + lean_dec_ref(x_79); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_75; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_74); +if (lean_is_scalar(x_72)) { + x_84 = lean_alloc_ctor(0, 2, 0); +} else { + x_84 = x_72; +} +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_71); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_70); +if (lean_is_scalar(x_82)) { + x_86 = lean_alloc_ctor(0, 2, 0); +} else { + x_86 = x_82; +} +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_81); +return x_86; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_72); +lean_dec(x_71); +lean_dec(x_70); +x_87 = lean_ctor_get(x_79, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_79, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_89 = x_79; +} else { + lean_dec_ref(x_79); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +uint8_t x_91; +lean_dec(x_4); +lean_dec(x_1); +x_91 = !lean_is_exclusive(x_10); +if (x_91 == 0) +{ +lean_object* x_92; uint8_t x_93; +x_92 = lean_ctor_get(x_10, 0); +lean_dec(x_92); +x_93 = !lean_is_exclusive(x_11); +if (x_93 == 0) +{ +lean_object* x_94; uint8_t x_95; +x_94 = lean_ctor_get(x_11, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_12); +if (x_95 == 0) +{ +return x_10; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_12, 0); +x_97 = lean_ctor_get(x_12, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_12); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +lean_ctor_set(x_11, 0, x_98); +return x_10; +} +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_99 = lean_ctor_get(x_11, 1); +lean_inc(x_99); +lean_dec(x_11); +x_100 = lean_ctor_get(x_12, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_12, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_102 = x_12; +} else { + lean_dec_ref(x_12); + x_102 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_103 = lean_alloc_ctor(1, 2, 0); +} else { + x_103 = x_102; +} +lean_ctor_set(x_103, 0, x_100); +lean_ctor_set(x_103, 1, x_101); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_99); +lean_ctor_set(x_10, 0, x_104); +return x_10; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_105 = lean_ctor_get(x_10, 1); +lean_inc(x_105); +lean_dec(x_10); +x_106 = lean_ctor_get(x_11, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_107 = x_11; +} else { + lean_dec_ref(x_11); + x_107 = lean_box(0); +} +x_108 = lean_ctor_get(x_12, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_12, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_110 = x_12; +} else { + lean_dec_ref(x_12); + x_110 = lean_box(0); +} +if (lean_is_scalar(x_110)) { + x_111 = lean_alloc_ctor(1, 2, 0); +} else { + x_111 = x_110; +} +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_109); +if (lean_is_scalar(x_107)) { + x_112 = lean_alloc_ctor(0, 2, 0); +} else { + x_112 = x_107; +} +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_106); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_105); +return x_113; +} +} +} +else +{ +uint8_t x_114; +lean_dec(x_4); +lean_dec(x_1); +x_114 = !lean_is_exclusive(x_10); +if (x_114 == 0) +{ +return x_10; +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_115 = lean_ctor_get(x_10, 0); +x_116 = lean_ctor_get(x_10, 1); +lean_inc(x_116); +lean_inc(x_115); +lean_dec(x_10); +x_117 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_117, 0, x_115); +lean_ctor_set(x_117, 1, x_116); +return x_117; +} +} +} +} +static lean_object* _init_l_Lake_Module_ileanFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_clearOutputHashes___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_ileanFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_ileanFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_ileanFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_ileanFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_ileanFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_ileanFacetConfig___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_2); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_4); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_5); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_ctor_get(x_1, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_7, 2); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_ctor_get(x_9, 8); +lean_inc(x_10); +x_11 = l_System_FilePath_join(x_8, x_10); +x_12 = lean_ctor_get(x_9, 12); +lean_inc(x_12); +lean_dec(x_9); +x_13 = l_System_FilePath_join(x_11, x_12); +x_14 = lean_ctor_get(x_1, 1); +lean_inc(x_14); +lean_dec(x_1); +x_15 = l_Lake_Module_clearOutputHashes___closed__2; +x_16 = l_Lean_modToFilePath(x_13, x_14, x_15); +lean_dec(x_13); +lean_inc(x_16); +x_17 = lean_alloc_closure((void*)(l_Lake_fetchFileTrace___boxed), 4, 1); +lean_closure_set(x_17, 0, x_16); +x_18 = lean_alloc_closure((void*)(l_Lake_Module_cFacetConfig___elambda__1___lambda__1___boxed), 5, 1); +lean_closure_set(x_18, 0, x_16); +x_19 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_19, 0, x_17); +lean_closure_set(x_19, 1, x_18); +x_20 = 1; +lean_inc(x_2); +x_21 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_19, x_20, x_2, x_5, x_4); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; +x_22 = lean_ctor_get(x_21, 0); +lean_inc(x_22); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_21, 1); +lean_inc(x_24); +lean_dec(x_21); +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +lean_dec(x_22); +x_26 = lean_ctor_get(x_23, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_23, 1); +lean_inc(x_27); +lean_dec(x_23); +x_28 = l_String_isEmpty(x_26); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; uint8_t x_35; +x_29 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_30 = lean_string_append(x_29, x_26); +lean_dec(x_26); +x_31 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_32 = lean_string_append(x_30, x_31); +x_33 = 1; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = !lean_is_exclusive(x_25); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = lean_ctor_get(x_25, 0); +x_37 = lean_array_push(x_36, x_34); +lean_ctor_set(x_25, 0, x_37); +x_38 = lean_box(0); +x_39 = l_Lake_Module_recBuildLean___lambda__4(x_27, x_38, x_2, x_25, x_24); +lean_dec(x_2); +return x_39; +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_40 = lean_ctor_get(x_25, 0); +x_41 = lean_ctor_get_uint8(x_25, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_25); +x_42 = lean_array_push(x_40, x_34); +x_43 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set_uint8(x_43, sizeof(void*)*1, x_41); +x_44 = lean_box(0); +x_45 = l_Lake_Module_recBuildLean___lambda__4(x_27, x_44, x_2, x_43, x_24); +lean_dec(x_2); +return x_45; +} +} +else +{ +lean_object* x_46; lean_object* x_47; +lean_dec(x_26); +x_46 = lean_box(0); +x_47 = l_Lake_Module_recBuildLean___lambda__4(x_27, x_46, x_2, x_25, x_24); +lean_dec(x_2); +return x_47; +} +} +else +{ +uint8_t x_48; +lean_dec(x_2); +x_48 = !lean_is_exclusive(x_21); +if (x_48 == 0) +{ +lean_object* x_49; uint8_t x_50; +x_49 = lean_ctor_get(x_21, 0); +lean_dec(x_49); +x_50 = !lean_is_exclusive(x_22); +if (x_50 == 0) +{ +return x_21; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_22, 0); +x_52 = lean_ctor_get(x_22, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_22); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +lean_ctor_set(x_21, 0, x_53); +return x_21; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_54 = lean_ctor_get(x_21, 1); +lean_inc(x_54); +lean_dec(x_21); +x_55 = lean_ctor_get(x_22, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_22, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_57 = x_22; +} else { + lean_dec_ref(x_22); + x_57 = lean_box(0); +} +if (lean_is_scalar(x_57)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_57; +} +lean_ctor_set(x_58, 0, x_55); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_54); +return x_59; +} +} +} +else +{ +uint8_t x_60; +lean_dec(x_2); +x_60 = !lean_is_exclusive(x_21); +if (x_60 == 0) +{ +return x_21; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_61 = lean_ctor_get(x_21, 0); +x_62 = lean_ctor_get(x_21, 1); +lean_inc(x_62); +lean_inc(x_61); +lean_dec(x_21); +x_63 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set(x_63, 1, x_62); +return x_63; +} +} +} +else +{ +uint8_t x_64; +lean_dec(x_2); +lean_dec(x_1); +x_64 = !lean_is_exclusive(x_3); +if (x_64 == 0) +{ +lean_object* x_65; +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_3); +lean_ctor_set(x_65, 1, x_4); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_66 = lean_ctor_get(x_3, 0); +x_67 = lean_ctor_get(x_3, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_3); +x_68 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_4); +return x_69; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Lake_Module_leanArtsFacetConfig___closed__4; +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +lean_inc(x_4); +x_10 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_dec(x_10); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_16 = lean_ctor_get(x_11, 1); +x_17 = lean_ctor_get(x_11, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_12); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_19 = lean_ctor_get(x_12, 1); +x_20 = lean_ctor_get(x_12, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_13); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_13, 0); +x_23 = lean_ctor_get(x_13, 1); +x_24 = lean_alloc_closure((void*)(l_Lake_Module_cFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_24, 0, x_1); +lean_closure_set(x_24, 1, x_4); +x_25 = l_Task_Priority_default; +x_26 = 0; +x_27 = lean_io_map_task(x_24, x_22, x_25, x_26, x_14); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; +x_29 = lean_ctor_get(x_27, 0); +lean_ctor_set(x_13, 0, x_29); +lean_ctor_set(x_27, 0, x_11); +return x_27; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_27, 0); +x_31 = lean_ctor_get(x_27, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_27); +lean_ctor_set(x_13, 0, x_30); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_11); +lean_ctor_set(x_32, 1, x_31); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_free_object(x_13); +lean_dec(x_23); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_33 = !lean_is_exclusive(x_27); +if (x_33 == 0) +{ +return x_27; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_27, 0); +x_35 = lean_ctor_get(x_27, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_27); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; +x_37 = lean_ctor_get(x_13, 0); +x_38 = lean_ctor_get(x_13, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_13); +x_39 = lean_alloc_closure((void*)(l_Lake_Module_cFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_39, 0, x_1); +lean_closure_set(x_39, 1, x_4); +x_40 = l_Task_Priority_default; +x_41 = 0; +x_42 = lean_io_map_task(x_39, x_37, x_40, x_41, x_14); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_38); +lean_ctor_set(x_12, 0, x_46); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_11); +lean_ctor_set(x_47, 1, x_44); +return x_47; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_dec(x_38); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_48 = lean_ctor_get(x_42, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_42, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_50 = x_42; +} else { + lean_dec_ref(x_42); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +return x_51; +} +} +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; +x_52 = lean_ctor_get(x_12, 1); +lean_inc(x_52); +lean_dec(x_12); +x_53 = lean_ctor_get(x_13, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_13, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_55 = x_13; +} else { + lean_dec_ref(x_13); + x_55 = lean_box(0); +} +x_56 = lean_alloc_closure((void*)(l_Lake_Module_cFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_56, 0, x_1); +lean_closure_set(x_56, 1, x_4); +x_57 = l_Task_Priority_default; +x_58 = 0; +x_59 = lean_io_map_task(x_56, x_53, x_57, x_58, x_14); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_60 = lean_ctor_get(x_59, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_59, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_62 = x_59; +} else { + lean_dec_ref(x_59); + x_62 = lean_box(0); +} +if (lean_is_scalar(x_55)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_55; +} +lean_ctor_set(x_63, 0, x_60); +lean_ctor_set(x_63, 1, x_54); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_52); +lean_ctor_set(x_11, 0, x_64); +if (lean_is_scalar(x_62)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_62; +} +lean_ctor_set(x_65, 0, x_11); +lean_ctor_set(x_65, 1, x_61); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_55); +lean_dec(x_54); +lean_dec(x_52); +lean_free_object(x_11); +lean_dec(x_16); +x_66 = lean_ctor_get(x_59, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_68 = x_59; +} else { + lean_dec_ref(x_59); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +return x_69; +} +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; +x_70 = lean_ctor_get(x_11, 1); +lean_inc(x_70); +lean_dec(x_11); +x_71 = lean_ctor_get(x_12, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_72 = x_12; +} else { + lean_dec_ref(x_12); + x_72 = lean_box(0); +} +x_73 = lean_ctor_get(x_13, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_13, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_75 = x_13; +} else { + lean_dec_ref(x_13); + x_75 = lean_box(0); +} +x_76 = lean_alloc_closure((void*)(l_Lake_Module_cFacetConfig___elambda__1___lambda__2), 4, 2); +lean_closure_set(x_76, 0, x_1); +lean_closure_set(x_76, 1, x_4); +x_77 = l_Task_Priority_default; +x_78 = 0; +x_79 = lean_io_map_task(x_76, x_73, x_77, x_78, x_14); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_79, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_82 = x_79; +} else { + lean_dec_ref(x_79); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_75; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_74); +if (lean_is_scalar(x_72)) { + x_84 = lean_alloc_ctor(0, 2, 0); +} else { + x_84 = x_72; +} +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_71); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_70); +if (lean_is_scalar(x_82)) { + x_86 = lean_alloc_ctor(0, 2, 0); +} else { + x_86 = x_82; +} +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_81); +return x_86; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_72); +lean_dec(x_71); +lean_dec(x_70); +x_87 = lean_ctor_get(x_79, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_79, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_89 = x_79; +} else { + lean_dec_ref(x_79); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +uint8_t x_91; +lean_dec(x_4); +lean_dec(x_1); +x_91 = !lean_is_exclusive(x_10); +if (x_91 == 0) +{ +lean_object* x_92; uint8_t x_93; +x_92 = lean_ctor_get(x_10, 0); +lean_dec(x_92); +x_93 = !lean_is_exclusive(x_11); +if (x_93 == 0) +{ +lean_object* x_94; uint8_t x_95; +x_94 = lean_ctor_get(x_11, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_12); +if (x_95 == 0) +{ +return x_10; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_12, 0); +x_97 = lean_ctor_get(x_12, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_12); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +lean_ctor_set(x_11, 0, x_98); +return x_10; +} +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_99 = lean_ctor_get(x_11, 1); +lean_inc(x_99); +lean_dec(x_11); +x_100 = lean_ctor_get(x_12, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_12, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_102 = x_12; +} else { + lean_dec_ref(x_12); + x_102 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_103 = lean_alloc_ctor(1, 2, 0); +} else { + x_103 = x_102; +} +lean_ctor_set(x_103, 0, x_100); +lean_ctor_set(x_103, 1, x_101); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_99); +lean_ctor_set(x_10, 0, x_104); +return x_10; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_105 = lean_ctor_get(x_10, 1); +lean_inc(x_105); +lean_dec(x_10); +x_106 = lean_ctor_get(x_11, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_107 = x_11; +} else { + lean_dec_ref(x_11); + x_107 = lean_box(0); +} +x_108 = lean_ctor_get(x_12, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_12, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_110 = x_12; +} else { + lean_dec_ref(x_12); + x_110 = lean_box(0); +} +if (lean_is_scalar(x_110)) { + x_111 = lean_alloc_ctor(1, 2, 0); +} else { + x_111 = x_110; +} +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_109); +if (lean_is_scalar(x_107)) { + x_112 = lean_alloc_ctor(0, 2, 0); +} else { + x_112 = x_107; +} +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_106); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_105); +return x_113; +} +} +} +else +{ +uint8_t x_114; +lean_dec(x_4); +lean_dec(x_1); +x_114 = !lean_is_exclusive(x_10); +if (x_114 == 0) +{ +return x_10; +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_115 = lean_ctor_get(x_10, 0); +x_116 = lean_ctor_get(x_10, 1); +lean_inc(x_116); +lean_inc(x_115); +lean_dec(x_10); +x_117 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_117, 0, x_115); +lean_ctor_set(x_117, 1, x_116); +return x_117; +} +} +} +} +static lean_object* _init_l_Lake_Module_cFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_clearOutputHashes___closed__2; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_cFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_cFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_cFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_cFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_cFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_cFacetConfig___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_cFacetConfig___elambda__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Module_cFacetConfig___elambda__1___lambda__1(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_bcFacetConfig___elambda__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_ctor_get(x_1, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_7, 2); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_ctor_get(x_9, 8); +lean_inc(x_10); +x_11 = l_System_FilePath_join(x_8, x_10); +x_12 = lean_ctor_get(x_9, 12); +lean_inc(x_12); +lean_dec(x_9); +x_13 = l_System_FilePath_join(x_11, x_12); +x_14 = lean_ctor_get(x_1, 1); +lean_inc(x_14); +lean_dec(x_1); +x_15 = l_Lake_Module_clearOutputHashes___closed__4; +x_16 = l_Lean_modToFilePath(x_13, x_14, x_15); +lean_dec(x_13); +lean_inc(x_16); +x_17 = lean_alloc_closure((void*)(l_Lake_fetchFileTrace___boxed), 4, 1); +lean_closure_set(x_17, 0, x_16); +x_18 = lean_alloc_closure((void*)(l_Lake_Module_cFacetConfig___elambda__1___lambda__1___boxed), 5, 1); +lean_closure_set(x_18, 0, x_16); +x_19 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_19, 0, x_17); +lean_closure_set(x_19, 1, x_18); +x_20 = 1; +lean_inc(x_2); +x_21 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_19, x_20, x_2, x_5, x_4); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; +x_22 = lean_ctor_get(x_21, 0); +lean_inc(x_22); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +x_24 = lean_ctor_get(x_21, 1); +lean_inc(x_24); +lean_dec(x_21); +x_25 = lean_ctor_get(x_22, 1); +lean_inc(x_25); +lean_dec(x_22); +x_26 = lean_ctor_get(x_23, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_23, 1); +lean_inc(x_27); +lean_dec(x_23); +x_28 = l_String_isEmpty(x_26); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; uint8_t x_35; +x_29 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_30 = lean_string_append(x_29, x_26); +lean_dec(x_26); +x_31 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_32 = lean_string_append(x_30, x_31); +x_33 = 1; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = !lean_is_exclusive(x_25); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = lean_ctor_get(x_25, 0); +x_37 = lean_array_push(x_36, x_34); +lean_ctor_set(x_25, 0, x_37); +x_38 = lean_box(0); +x_39 = l_Lake_Module_recBuildLean___lambda__4(x_27, x_38, x_2, x_25, x_24); +lean_dec(x_2); +return x_39; +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_40 = lean_ctor_get(x_25, 0); +x_41 = lean_ctor_get_uint8(x_25, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_25); +x_42 = lean_array_push(x_40, x_34); +x_43 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set_uint8(x_43, sizeof(void*)*1, x_41); +x_44 = lean_box(0); +x_45 = l_Lake_Module_recBuildLean___lambda__4(x_27, x_44, x_2, x_43, x_24); +lean_dec(x_2); +return x_45; +} +} +else +{ +lean_object* x_46; lean_object* x_47; +lean_dec(x_26); +x_46 = lean_box(0); +x_47 = l_Lake_Module_recBuildLean___lambda__4(x_27, x_46, x_2, x_25, x_24); +lean_dec(x_2); +return x_47; +} +} +else +{ +uint8_t x_48; +lean_dec(x_2); +x_48 = !lean_is_exclusive(x_21); +if (x_48 == 0) +{ +lean_object* x_49; uint8_t x_50; +x_49 = lean_ctor_get(x_21, 0); +lean_dec(x_49); +x_50 = !lean_is_exclusive(x_22); +if (x_50 == 0) +{ +return x_21; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_22, 0); +x_52 = lean_ctor_get(x_22, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_22); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +lean_ctor_set(x_21, 0, x_53); +return x_21; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_54 = lean_ctor_get(x_21, 1); +lean_inc(x_54); +lean_dec(x_21); +x_55 = lean_ctor_get(x_22, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_22, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + lean_ctor_release(x_22, 1); + x_57 = x_22; +} else { + lean_dec_ref(x_22); + x_57 = lean_box(0); +} +if (lean_is_scalar(x_57)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_57; +} +lean_ctor_set(x_58, 0, x_55); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_54); +return x_59; +} +} +} +else +{ +uint8_t x_60; +lean_dec(x_2); +x_60 = !lean_is_exclusive(x_21); +if (x_60 == 0) +{ +return x_21; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_61 = lean_ctor_get(x_21, 0); +x_62 = lean_ctor_get(x_21, 1); +lean_inc(x_62); +lean_inc(x_61); +lean_dec(x_21); +x_63 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set(x_63, 1, x_62); +return x_63; +} +} +} +else +{ +uint8_t x_64; +lean_dec(x_2); +lean_dec(x_1); +x_64 = !lean_is_exclusive(x_3); +if (x_64 == 0) +{ +lean_object* x_65; +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_3); +lean_ctor_set(x_65, 1, x_4); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_66 = lean_ctor_get(x_3, 0); +x_67 = lean_ctor_get(x_3, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_3); +x_68 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_4); +return x_69; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_bcFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = l_Lake_Module_leanArtsFacetConfig___closed__4; +lean_inc(x_1); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_8); +lean_inc(x_4); +x_10 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_dec(x_10); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; +x_16 = lean_ctor_get(x_11, 1); +x_17 = lean_ctor_get(x_11, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_12); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_19 = lean_ctor_get(x_12, 1); +x_20 = lean_ctor_get(x_12, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_13); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; +x_22 = lean_ctor_get(x_13, 0); +x_23 = lean_ctor_get(x_13, 1); +x_24 = lean_alloc_closure((void*)(l_Lake_Module_bcFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_24, 0, x_1); +lean_closure_set(x_24, 1, x_4); +x_25 = l_Task_Priority_default; +x_26 = 0; +x_27 = lean_io_map_task(x_24, x_22, x_25, x_26, x_14); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; +x_29 = lean_ctor_get(x_27, 0); +lean_ctor_set(x_13, 0, x_29); +lean_ctor_set(x_27, 0, x_11); +return x_27; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_27, 0); +x_31 = lean_ctor_get(x_27, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_27); +lean_ctor_set(x_13, 0, x_30); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_11); +lean_ctor_set(x_32, 1, x_31); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_free_object(x_13); +lean_dec(x_23); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_33 = !lean_is_exclusive(x_27); +if (x_33 == 0) +{ +return x_27; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_27, 0); +x_35 = lean_ctor_get(x_27, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_27); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; +x_37 = lean_ctor_get(x_13, 0); +x_38 = lean_ctor_get(x_13, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_13); +x_39 = lean_alloc_closure((void*)(l_Lake_Module_bcFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_39, 0, x_1); +lean_closure_set(x_39, 1, x_4); +x_40 = l_Task_Priority_default; +x_41 = 0; +x_42 = lean_io_map_task(x_39, x_37, x_40, x_41, x_14); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_43); +lean_ctor_set(x_46, 1, x_38); +lean_ctor_set(x_12, 0, x_46); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_11); +lean_ctor_set(x_47, 1, x_44); +return x_47; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_dec(x_38); +lean_free_object(x_12); +lean_dec(x_19); +lean_free_object(x_11); +lean_dec(x_16); +x_48 = lean_ctor_get(x_42, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_42, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_50 = x_42; +} else { + lean_dec_ref(x_42); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +return x_51; +} +} +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; lean_object* x_59; +x_52 = lean_ctor_get(x_12, 1); +lean_inc(x_52); +lean_dec(x_12); +x_53 = lean_ctor_get(x_13, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_13, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_55 = x_13; +} else { + lean_dec_ref(x_13); + x_55 = lean_box(0); +} +x_56 = lean_alloc_closure((void*)(l_Lake_Module_bcFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_56, 0, x_1); +lean_closure_set(x_56, 1, x_4); +x_57 = l_Task_Priority_default; +x_58 = 0; +x_59 = lean_io_map_task(x_56, x_53, x_57, x_58, x_14); +if (lean_obj_tag(x_59) == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_60 = lean_ctor_get(x_59, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_59, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_62 = x_59; +} else { + lean_dec_ref(x_59); + x_62 = lean_box(0); +} +if (lean_is_scalar(x_55)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_55; +} +lean_ctor_set(x_63, 0, x_60); +lean_ctor_set(x_63, 1, x_54); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_52); +lean_ctor_set(x_11, 0, x_64); +if (lean_is_scalar(x_62)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_62; +} +lean_ctor_set(x_65, 0, x_11); +lean_ctor_set(x_65, 1, x_61); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_55); +lean_dec(x_54); +lean_dec(x_52); +lean_free_object(x_11); +lean_dec(x_16); +x_66 = lean_ctor_get(x_59, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_59, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_59)) { + lean_ctor_release(x_59, 0); + lean_ctor_release(x_59, 1); + x_68 = x_59; +} else { + lean_dec_ref(x_59); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +return x_69; +} +} +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; +x_70 = lean_ctor_get(x_11, 1); +lean_inc(x_70); +lean_dec(x_11); +x_71 = lean_ctor_get(x_12, 1); +lean_inc(x_71); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_72 = x_12; +} else { + lean_dec_ref(x_12); + x_72 = lean_box(0); +} +x_73 = lean_ctor_get(x_13, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_13, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_75 = x_13; +} else { + lean_dec_ref(x_13); + x_75 = lean_box(0); +} +x_76 = lean_alloc_closure((void*)(l_Lake_Module_bcFacetConfig___elambda__1___lambda__1), 4, 2); +lean_closure_set(x_76, 0, x_1); +lean_closure_set(x_76, 1, x_4); +x_77 = l_Task_Priority_default; +x_78 = 0; +x_79 = lean_io_map_task(x_76, x_73, x_77, x_78, x_14); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_79, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_82 = x_79; +} else { + lean_dec_ref(x_79); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_83 = lean_alloc_ctor(0, 2, 0); +} else { + x_83 = x_75; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_74); +if (lean_is_scalar(x_72)) { + x_84 = lean_alloc_ctor(0, 2, 0); +} else { + x_84 = x_72; +} +lean_ctor_set(x_84, 0, x_83); +lean_ctor_set(x_84, 1, x_71); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_70); +if (lean_is_scalar(x_82)) { + x_86 = lean_alloc_ctor(0, 2, 0); +} else { + x_86 = x_82; +} +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_81); +return x_86; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_75); +lean_dec(x_74); +lean_dec(x_72); +lean_dec(x_71); +lean_dec(x_70); +x_87 = lean_ctor_get(x_79, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_79, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_89 = x_79; +} else { + lean_dec_ref(x_79); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +uint8_t x_91; +lean_dec(x_4); +lean_dec(x_1); +x_91 = !lean_is_exclusive(x_10); +if (x_91 == 0) +{ +lean_object* x_92; uint8_t x_93; +x_92 = lean_ctor_get(x_10, 0); +lean_dec(x_92); +x_93 = !lean_is_exclusive(x_11); +if (x_93 == 0) +{ +lean_object* x_94; uint8_t x_95; +x_94 = lean_ctor_get(x_11, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_12); +if (x_95 == 0) +{ +return x_10; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_12, 0); +x_97 = lean_ctor_get(x_12, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_12); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +lean_ctor_set(x_11, 0, x_98); +return x_10; +} +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_99 = lean_ctor_get(x_11, 1); +lean_inc(x_99); +lean_dec(x_11); +x_100 = lean_ctor_get(x_12, 0); +lean_inc(x_100); +x_101 = lean_ctor_get(x_12, 1); +lean_inc(x_101); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_102 = x_12; +} else { + lean_dec_ref(x_12); + x_102 = lean_box(0); +} +if (lean_is_scalar(x_102)) { + x_103 = lean_alloc_ctor(1, 2, 0); +} else { + x_103 = x_102; +} +lean_ctor_set(x_103, 0, x_100); +lean_ctor_set(x_103, 1, x_101); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_99); +lean_ctor_set(x_10, 0, x_104); +return x_10; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_105 = lean_ctor_get(x_10, 1); +lean_inc(x_105); +lean_dec(x_10); +x_106 = lean_ctor_get(x_11, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_107 = x_11; +} else { + lean_dec_ref(x_11); + x_107 = lean_box(0); +} +x_108 = lean_ctor_get(x_12, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_12, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_110 = x_12; +} else { + lean_dec_ref(x_12); + x_110 = lean_box(0); +} +if (lean_is_scalar(x_110)) { + x_111 = lean_alloc_ctor(1, 2, 0); +} else { + x_111 = x_110; +} +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_109); +if (lean_is_scalar(x_107)) { + x_112 = lean_alloc_ctor(0, 2, 0); +} else { + x_112 = x_107; +} +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_106); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_105); +return x_113; +} +} +} +else +{ +uint8_t x_114; +lean_dec(x_4); +lean_dec(x_1); +x_114 = !lean_is_exclusive(x_10); +if (x_114 == 0) +{ +return x_10; +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_115 = lean_ctor_get(x_10, 0); +x_116 = lean_ctor_get(x_10, 1); +lean_inc(x_116); +lean_inc(x_115); +lean_dec(x_10); +x_117 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_117, 0, x_115); +lean_ctor_set(x_117, 1, x_116); +return x_117; +} +} +} +} +static lean_object* _init_l_Lake_Module_bcFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_clearOutputHashes___closed__4; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bcFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_bcFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_bcFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_bcFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bcFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_bcFacetConfig___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_1, 2); +lean_inc(x_4); +x_5 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_5, 0, x_4); +lean_ctor_set(x_5, 1, x_2); +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint64_t x_6; uint64_t x_7; uint64_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_6 = l_Lake_computeArrayHash___at_Lake_buildO___spec__1(x_1); +x_7 = l_Lake_platformTrace; +x_8 = lean_uint64_mix_hash(x_6, x_7); +x_9 = l_Lake_Module_recBuildDeps___lambda__1___closed__2; +x_10 = lean_box_uint64(x_8); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_9); +x_12 = l_Lake_BuildTrace_mix(x_2, x_11); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_4); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_5); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_4 = lean_ctor_get(x_1, 1); +x_5 = lean_ctor_get(x_4, 1); +x_6 = lean_ctor_get(x_5, 1); +x_7 = lean_ctor_get(x_6, 8); +lean_inc(x_7); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_2); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_3); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; uint8_t x_10; +x_9 = l_Array_append___rarg(x_1, x_2); +x_10 = !lean_is_exclusive(x_7); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_7, 0); +x_12 = l_Lake_compileO(x_3, x_4, x_9, x_5, x_11, x_8); +lean_dec(x_9); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_12); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_12, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_13); +if (x_16 == 0) +{ +lean_object* x_17; +x_17 = lean_ctor_get(x_13, 1); +lean_ctor_set(x_7, 0, x_17); +lean_ctor_set(x_13, 1, x_7); +return x_12; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_13, 0); +x_19 = lean_ctor_get(x_13, 1); +lean_inc(x_19); +lean_inc(x_18); +lean_dec(x_13); +lean_ctor_set(x_7, 0, x_19); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_7); +lean_ctor_set(x_12, 0, x_20); +return x_12; +} +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_21 = lean_ctor_get(x_12, 1); +lean_inc(x_21); +lean_dec(x_12); +x_22 = lean_ctor_get(x_13, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_13, 1); +lean_inc(x_23); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_24 = x_13; +} else { + lean_dec_ref(x_13); + x_24 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_23); +if (lean_is_scalar(x_24)) { + x_25 = lean_alloc_ctor(0, 2, 0); +} else { + x_25 = x_24; +} +lean_ctor_set(x_25, 0, x_22); +lean_ctor_set(x_25, 1, x_7); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_21); +return x_26; +} +} +else +{ +uint8_t x_27; +x_27 = !lean_is_exclusive(x_12); +if (x_27 == 0) +{ +lean_object* x_28; uint8_t x_29; +x_28 = lean_ctor_get(x_12, 0); +lean_dec(x_28); +x_29 = !lean_is_exclusive(x_13); +if (x_29 == 0) +{ +lean_object* x_30; +x_30 = lean_ctor_get(x_13, 1); +lean_ctor_set(x_7, 0, x_30); +lean_ctor_set(x_13, 1, x_7); +return x_12; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_13, 0); +x_32 = lean_ctor_get(x_13, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_13); +lean_ctor_set(x_7, 0, x_32); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_7); +lean_ctor_set(x_12, 0, x_33); +return x_12; +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_12, 1); +lean_inc(x_34); +lean_dec(x_12); +x_35 = lean_ctor_get(x_13, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_13, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_37 = x_13; +} else { + lean_dec_ref(x_13); + x_37 = lean_box(0); +} +lean_ctor_set(x_7, 0, x_36); +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(1, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_7); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_34); +return x_39; +} +} +} +else +{ +lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; +x_40 = lean_ctor_get(x_7, 0); +x_41 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_40); +lean_dec(x_7); +x_42 = l_Lake_compileO(x_3, x_4, x_9, x_5, x_40, x_8); +lean_dec(x_9); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; +} else { + lean_dec_ref(x_42); + x_45 = lean_box(0); +} +x_46 = lean_ctor_get(x_43, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_43, 1); +lean_inc(x_47); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_48 = x_43; +} else { + lean_dec_ref(x_43); + x_48 = lean_box(0); +} +x_49 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set_uint8(x_49, sizeof(void*)*1, x_41); +if (lean_is_scalar(x_48)) { + x_50 = lean_alloc_ctor(0, 2, 0); +} else { + x_50 = x_48; +} +lean_ctor_set(x_50, 0, x_46); +lean_ctor_set(x_50, 1, x_49); +if (lean_is_scalar(x_45)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_45; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_44); +return x_51; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_52 = lean_ctor_get(x_42, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_53 = x_42; +} else { + lean_dec_ref(x_42); + x_53 = lean_box(0); +} +x_54 = lean_ctor_get(x_43, 0); +lean_inc(x_54); +x_55 = lean_ctor_get(x_43, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_56 = x_43; +} else { + lean_dec_ref(x_43); + x_56 = lean_box(0); +} +x_57 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set_uint8(x_57, sizeof(void*)*1, x_41); +if (lean_is_scalar(x_56)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_56; +} +lean_ctor_set(x_58, 0, x_54); +lean_ctor_set(x_58, 1, x_57); +if (lean_is_scalar(x_53)) { + x_59 = lean_alloc_ctor(0, 2, 0); +} else { + x_59 = x_53; +} +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_52); +return x_59; +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___lambda__5___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__3___boxed), 3, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_10 = l_Lake_BuildTrace_mix(x_1, x_6); +lean_inc(x_4); +x_11 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__4___boxed), 8, 4); +lean_closure_set(x_11, 0, x_2); +lean_closure_set(x_11, 1, x_3); +lean_closure_set(x_11, 2, x_4); +lean_closure_set(x_11, 3, x_5); +x_12 = l_Lake_Module_recBuildLeanCToOExport___lambda__5___closed__1; +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_12); +lean_closure_set(x_13, 1, x_11); +lean_inc(x_4); +x_14 = l_Lake_buildFileUnlessUpToDate(x_4, x_10, x_13, x_7, x_8, x_9); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +x_16 = !lean_is_exclusive(x_14); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_14, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_15); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_15, 0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_4); +lean_ctor_set(x_20, 1, x_19); +lean_ctor_set(x_15, 0, x_20); +return x_14; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_15, 0); +x_22 = lean_ctor_get(x_15, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_15); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_4); +lean_ctor_set(x_23, 1, x_21); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_14, 0, x_24); +return x_14; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_14, 1); +lean_inc(x_25); +lean_dec(x_14); +x_26 = lean_ctor_get(x_15, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_15, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_28 = x_15; +} else { + lean_dec_ref(x_15); + x_28 = lean_box(0); +} +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_4); +lean_ctor_set(x_29, 1, x_26); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_25); +return x_31; +} +} +else +{ +uint8_t x_32; +lean_dec(x_4); +x_32 = !lean_is_exclusive(x_14); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_14, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_15); +if (x_34 == 0) +{ +return x_14; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_15, 0); +x_36 = lean_ctor_get(x_15, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_15); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_14, 0, x_37); +return x_14; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_14, 1); +lean_inc(x_38); +lean_dec(x_14); +x_39 = lean_ctor_get(x_15, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_15, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_41 = x_15; +} else { + lean_dec_ref(x_15); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_4); +x_44 = !lean_is_exclusive(x_14); +if (x_44 == 0) +{ +return x_14; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_14, 0); +x_46 = lean_ctor_get(x_14, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_14); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__5), 9, 5); +lean_closure_set(x_12, 0, x_11); +lean_closure_set(x_12, 1, x_1); +lean_closure_set(x_12, 2, x_2); +lean_closure_set(x_12, 3, x_3); +lean_closure_set(x_12, 4, x_10); +x_13 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_13, 0, x_4); +lean_closure_set(x_13, 1, x_12); +x_14 = 1; +lean_inc(x_5); +x_15 = l_IO_FS_withIsolatedStreams___at_Lake_buildFileAfterDep___spec__1(x_13, x_14, x_5, x_9, x_7); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_15, 1); +lean_inc(x_18); +lean_dec(x_15); +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +lean_dec(x_17); +x_22 = l_String_isEmpty(x_20); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; uint8_t x_29; +x_23 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_24 = lean_string_append(x_23, x_20); +lean_dec(x_20); +x_25 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_26 = lean_string_append(x_24, x_25); +x_27 = 1; +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_27); +x_29 = !lean_is_exclusive(x_19); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_19, 0); +x_31 = lean_array_push(x_30, x_28); +lean_ctor_set(x_19, 0, x_31); +x_32 = lean_box(0); +x_33 = l_Lake_Module_recBuildLean___lambda__4(x_21, x_32, x_5, x_19, x_18); +lean_dec(x_5); +return x_33; +} +else +{ +lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_34 = lean_ctor_get(x_19, 0); +x_35 = lean_ctor_get_uint8(x_19, sizeof(void*)*1); +lean_inc(x_34); +lean_dec(x_19); +x_36 = lean_array_push(x_34, x_28); +x_37 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set_uint8(x_37, sizeof(void*)*1, x_35); +x_38 = lean_box(0); +x_39 = l_Lake_Module_recBuildLean___lambda__4(x_21, x_38, x_5, x_37, x_18); +lean_dec(x_5); +return x_39; +} +} +else +{ +lean_object* x_40; lean_object* x_41; +lean_dec(x_20); +x_40 = lean_box(0); +x_41 = l_Lake_Module_recBuildLean___lambda__4(x_21, x_40, x_5, x_19, x_18); +lean_dec(x_5); +return x_41; +} +} +else +{ +uint8_t x_42; +lean_dec(x_5); +x_42 = !lean_is_exclusive(x_15); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_15, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_16); +if (x_44 == 0) +{ +return x_15; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_16, 0); +x_46 = lean_ctor_get(x_16, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_16); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +lean_ctor_set(x_15, 0, x_47); +return x_15; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_48 = lean_ctor_get(x_15, 1); +lean_inc(x_48); +lean_dec(x_15); +x_49 = lean_ctor_get(x_16, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_16, 1); +lean_inc(x_50); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_51 = x_16; +} else { + lean_dec_ref(x_16); + x_51 = lean_box(0); +} +if (lean_is_scalar(x_51)) { + x_52 = lean_alloc_ctor(1, 2, 0); +} else { + x_52 = x_51; +} +lean_ctor_set(x_52, 0, x_49); +lean_ctor_set(x_52, 1, x_50); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_48); +return x_53; +} +} +} +else +{ +uint8_t x_54; +lean_dec(x_5); +x_54 = !lean_is_exclusive(x_15); +if (x_54 == 0) +{ +return x_15; +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_15, 0); +x_56 = lean_ctor_get(x_15, 1); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_15); +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set(x_57, 1, x_56); +return x_57; +} +} +} +else +{ +uint8_t x_58; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_58 = !lean_is_exclusive(x_6); +if (x_58 == 0) +{ +lean_object* x_59; +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_6); +lean_ctor_set(x_59, 1, x_7); +return x_59; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_60 = lean_ctor_get(x_6, 0); +x_61 = lean_ctor_get(x_6, 1); +lean_inc(x_61); +lean_inc(x_60); +lean_dec(x_6); +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_7); +return x_63; +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("c.o.export", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__1___boxed), 3, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__7(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +_start: +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; +x_14 = lean_ctor_get(x_1, 0); +lean_inc(x_14); +lean_dec(x_1); +x_15 = lean_ctor_get(x_2, 8); +lean_inc(x_15); +x_16 = l_System_FilePath_join(x_14, x_15); +x_17 = lean_ctor_get(x_2, 12); +lean_inc(x_17); +lean_dec(x_2); +x_18 = l_System_FilePath_join(x_16, x_17); +x_19 = l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__1; +x_20 = l_Lean_modToFilePath(x_18, x_3, x_19); +lean_dec(x_18); +x_21 = lean_ctor_get(x_4, 5); +lean_inc(x_21); +lean_dec(x_4); +x_22 = lean_ctor_get(x_5, 5); +x_23 = l_Array_append___rarg(x_21, x_22); +lean_inc(x_6); +x_24 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__2___boxed), 5, 1); +lean_closure_set(x_24, 0, x_6); +x_25 = l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2; +x_26 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_26, 0, x_25); +lean_closure_set(x_26, 1, x_24); +x_27 = !lean_is_exclusive(x_7); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_7, 0); +x_29 = lean_ctor_get(x_7, 1); +x_30 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__6), 7, 5); +lean_closure_set(x_30, 0, x_23); +lean_closure_set(x_30, 1, x_6); +lean_closure_set(x_30, 2, x_20); +lean_closure_set(x_30, 3, x_26); +lean_closure_set(x_30, 4, x_10); +x_31 = l_Task_Priority_default; +x_32 = 0; +x_33 = lean_io_map_task(x_30, x_28, x_31, x_32, x_13); +if (lean_obj_tag(x_33) == 0) +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_33); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_33, 0); +lean_ctor_set(x_7, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_7); +lean_ctor_set(x_36, 1, x_11); +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set(x_37, 1, x_12); +lean_ctor_set(x_33, 0, x_37); +return x_33; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_38 = lean_ctor_get(x_33, 0); +x_39 = lean_ctor_get(x_33, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_33); +lean_ctor_set(x_7, 0, x_38); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_7); +lean_ctor_set(x_40, 1, x_11); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_12); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_39); +return x_42; +} +} +else +{ +uint8_t x_43; +lean_free_object(x_7); +lean_dec(x_29); +lean_dec(x_12); +lean_dec(x_11); +x_43 = !lean_is_exclusive(x_33); +if (x_43 == 0) +{ +return x_33; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_33, 0); +x_45 = lean_ctor_get(x_33, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_33); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +return x_46; +} +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_47 = lean_ctor_get(x_7, 0); +x_48 = lean_ctor_get(x_7, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_7); +x_49 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__6), 7, 5); +lean_closure_set(x_49, 0, x_23); +lean_closure_set(x_49, 1, x_6); +lean_closure_set(x_49, 2, x_20); +lean_closure_set(x_49, 3, x_26); +lean_closure_set(x_49, 4, x_10); +x_50 = l_Task_Priority_default; +x_51 = 0; +x_52 = lean_io_map_task(x_49, x_47, x_50, x_51, x_13); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_53 = lean_ctor_get(x_52, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_52, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_55 = x_52; +} else { + lean_dec_ref(x_52); + x_55 = lean_box(0); +} +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_53); +lean_ctor_set(x_56, 1, x_48); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_11); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_12); +if (lean_is_scalar(x_55)) { + x_59 = lean_alloc_ctor(0, 2, 0); +} else { + x_59 = x_55; +} +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_54); +return x_59; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +lean_dec(x_48); +lean_dec(x_12); +lean_dec(x_11); +x_60 = lean_ctor_get(x_52, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_52, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_62 = x_52; +} else { + lean_dec_ref(x_52); + x_62 = lean_box(0); +} +if (lean_is_scalar(x_62)) { + x_63 = lean_alloc_ctor(1, 2, 0); +} else { + x_63 = x_62; +} +lean_ctor_set(x_63, 0, x_60); +lean_ctor_set(x_63, 1, x_61); +return x_63; +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":c.o", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-DLEAN_EXPORTING", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_recBuildLeanCToOExport___closed__2; +x_2 = l_Lake_Module_recBuildLeanCToOExport___closed__3; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToOExport___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" (with exports)", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_8 = lean_ctor_get(x_4, 0); +lean_inc(x_8); +x_9 = lean_ctor_get_uint8(x_8, sizeof(void*)*1 + 3); +lean_dec(x_8); +x_10 = 2; +x_11 = l_Lake_instDecidableEqVerbosity(x_9, x_10); +x_12 = lean_ctor_get(x_1, 1); +lean_inc(x_12); +x_13 = 1; +lean_inc(x_12); +x_14 = l_Lean_Name_toString(x_12, x_13); +x_15 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_16 = lean_string_append(x_15, x_14); +lean_dec(x_14); +x_17 = l_Lake_Module_recBuildLeanCToOExport___closed__1; +x_18 = lean_string_append(x_16, x_17); +x_19 = lean_ctor_get(x_1, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 2); +lean_inc(x_21); +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +x_23 = lean_ctor_get_uint8(x_22, sizeof(void*)*9); +x_24 = lean_ctor_get(x_19, 1); +lean_inc(x_24); +lean_dec(x_19); +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +lean_dec(x_24); +x_26 = lean_ctor_get_uint8(x_25, sizeof(void*)*9); +x_27 = l_Lake_instOrdBuildType; +x_28 = lean_box(x_23); +x_29 = lean_box(x_26); +x_30 = l_instDecidableRelLe___rarg(x_27, x_28, x_29); +x_31 = lean_ctor_get(x_22, 3); +lean_inc(x_31); +x_32 = lean_ctor_get(x_25, 3); +lean_inc(x_32); +x_33 = l_Lake_Module_cFacetConfig___closed__1; +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_1); +lean_ctor_set(x_34, 1, x_33); +x_35 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_35, 0, x_34); +lean_closure_set(x_35, 1, lean_box(0)); +if (x_11 == 0) +{ +x_36 = x_15; +goto block_52; +} +else +{ +lean_object* x_53; +x_53 = l_Lake_Module_recBuildLeanCToOExport___closed__5; +x_36 = x_53; +goto block_52; +} +block_52: +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_string_append(x_18, x_36); +lean_dec(x_36); +x_38 = lean_string_append(x_37, x_15); +if (x_30 == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = l_Lake_BuildType_leancArgs(x_26); +x_47 = l_Array_append___rarg(x_46, x_31); +lean_dec(x_31); +x_48 = l_Array_append___rarg(x_47, x_32); +lean_dec(x_32); +x_39 = x_48; +goto block_45; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = l_Lake_BuildType_leancArgs(x_23); +x_50 = l_Array_append___rarg(x_49, x_31); +lean_dec(x_31); +x_51 = l_Array_append___rarg(x_50, x_32); +lean_dec(x_32); +x_39 = x_51; +goto block_45; +} +block_45: +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_40 = l_Lake_Module_recBuildLeanCToOExport___closed__4; +x_41 = l_Array_append___rarg(x_39, x_40); +x_42 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__7___boxed), 13, 6); +lean_closure_set(x_42, 0, x_20); +lean_closure_set(x_42, 1, x_21); +lean_closure_set(x_42, 2, x_12); +lean_closure_set(x_42, 3, x_22); +lean_closure_set(x_42, 4, x_25); +lean_closure_set(x_42, 5, x_41); +x_43 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 2); +lean_closure_set(x_43, 0, x_35); +lean_closure_set(x_43, 1, x_42); +x_44 = l_Lake_withRegisterJob___rarg(x_38, x_43, x_2, x_3, x_4, x_5, x_6, x_7); +return x_44; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_Module_recBuildLeanCToOExport___lambda__1(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Module_recBuildLeanCToOExport___lambda__2(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_1); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_Module_recBuildLeanCToOExport___lambda__3(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_Module_recBuildLeanCToOExport___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_6); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToOExport___lambda__7___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +_start: +{ +lean_object* x_14; +x_14 = l_Lake_Module_recBuildLeanCToOExport___lambda__7(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_5); +return x_14; +} +} +static lean_object* _init_l_Lake_Module_coExportFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("o", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coExportFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("export", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coExportFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Module_clearOutputHashes___closed__2; +x_2 = l_Lake_Module_coExportFacetConfig___closed__1; +x_3 = l_Lake_Module_coExportFacetConfig___closed__2; +x_4 = l_Lean_Name_mkStr3(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_Module_coExportFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coExportFacetConfig___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_coExportFacetConfig___closed__4; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_coExportFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_coExportFacetConfig___closed__5; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToONoExport___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("c.o.noexport", 12); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToONoExport___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_10 = lean_ctor_get(x_1, 0); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_11, 2); +lean_inc(x_13); +lean_dec(x_11); +x_14 = lean_ctor_get(x_13, 8); +lean_inc(x_14); +x_15 = l_System_FilePath_join(x_12, x_14); +x_16 = lean_ctor_get(x_13, 12); +lean_inc(x_16); +x_17 = l_System_FilePath_join(x_15, x_16); +x_18 = l_Lake_Module_recBuildLeanCToONoExport___lambda__1___closed__1; +x_19 = l_Lean_modToFilePath(x_17, x_2, x_18); +lean_dec(x_17); +x_20 = lean_ctor_get(x_13, 1); +lean_inc(x_20); +lean_dec(x_13); +x_21 = lean_ctor_get(x_20, 5); +lean_inc(x_21); +x_22 = lean_ctor_get(x_10, 1); +lean_inc(x_22); +lean_dec(x_10); +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +lean_dec(x_22); +x_24 = lean_ctor_get(x_23, 5); +lean_inc(x_24); +x_25 = l_Array_append___rarg(x_21, x_24); +lean_dec(x_24); +x_26 = lean_ctor_get_uint8(x_20, sizeof(void*)*9); +x_27 = lean_ctor_get_uint8(x_23, sizeof(void*)*9); +x_28 = l_Lake_instOrdBuildType; +x_29 = lean_box(x_26); +x_30 = lean_box(x_27); +x_31 = l_instDecidableRelLe___rarg(x_28, x_29, x_30); +x_32 = lean_ctor_get(x_20, 3); +lean_inc(x_32); +lean_dec(x_20); +x_33 = lean_ctor_get(x_23, 3); +lean_inc(x_33); +lean_dec(x_23); +x_34 = lean_ctor_get(x_3, 0); +lean_inc(x_34); +if (x_31 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = l_Lake_BuildType_leancArgs(x_27); +x_68 = l_Array_append___rarg(x_67, x_32); +lean_dec(x_32); +x_69 = l_Array_append___rarg(x_68, x_33); +lean_dec(x_33); +x_35 = x_69; +goto block_66; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = l_Lake_BuildType_leancArgs(x_26); +x_71 = l_Array_append___rarg(x_70, x_32); +lean_dec(x_32); +x_72 = l_Array_append___rarg(x_71, x_33); +lean_dec(x_33); +x_35 = x_72; +goto block_66; +} +block_66: +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; +lean_inc(x_35); +x_36 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__2___boxed), 5, 1); +lean_closure_set(x_36, 0, x_35); +x_37 = l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2; +x_38 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_38, 0, x_37); +lean_closure_set(x_38, 1, x_36); +x_39 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__6), 7, 5); +lean_closure_set(x_39, 0, x_25); +lean_closure_set(x_39, 1, x_35); +lean_closure_set(x_39, 2, x_19); +lean_closure_set(x_39, 3, x_38); +lean_closure_set(x_39, 4, x_6); +x_40 = l_Task_Priority_default; +x_41 = 0; +x_42 = lean_io_map_task(x_39, x_34, x_40, x_41, x_9); +if (lean_obj_tag(x_42) == 0) +{ +uint8_t x_43; +x_43 = !lean_is_exclusive(x_42); +if (x_43 == 0) +{ +uint8_t x_44; +x_44 = !lean_is_exclusive(x_3); +if (x_44 == 0) +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_45 = lean_ctor_get(x_42, 0); +x_46 = lean_ctor_get(x_3, 0); +lean_dec(x_46); +lean_ctor_set(x_3, 0, x_45); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_3); +lean_ctor_set(x_47, 1, x_7); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_8); +lean_ctor_set(x_42, 0, x_48); +return x_42; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_49 = lean_ctor_get(x_42, 0); +x_50 = lean_ctor_get(x_3, 1); +lean_inc(x_50); +lean_dec(x_3); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_7); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_8); +lean_ctor_set(x_42, 0, x_53); +return x_42; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_54 = lean_ctor_get(x_42, 0); +x_55 = lean_ctor_get(x_42, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_42); +x_56 = lean_ctor_get(x_3, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + x_57 = x_3; +} else { + lean_dec_ref(x_3); + x_57 = lean_box(0); +} +if (lean_is_scalar(x_57)) { + x_58 = lean_alloc_ctor(0, 2, 0); +} else { + x_58 = x_57; +} +lean_ctor_set(x_58, 0, x_54); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_7); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_8); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_55); +return x_61; +} +} +else +{ +uint8_t x_62; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_3); +x_62 = !lean_is_exclusive(x_42); +if (x_62 == 0) +{ +return x_42; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_42, 0); +x_64 = lean_ctor_get(x_42, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_42); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanCToONoExport___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" (without exports)", 18); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToONoExport(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; uint8_t x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_8 = lean_ctor_get(x_4, 0); +lean_inc(x_8); +x_9 = lean_ctor_get_uint8(x_8, sizeof(void*)*1 + 3); +lean_dec(x_8); +x_10 = 2; +x_11 = l_Lake_instDecidableEqVerbosity(x_9, x_10); +x_12 = lean_ctor_get(x_1, 1); +lean_inc(x_12); +x_13 = 1; +lean_inc(x_12); +x_14 = l_Lean_Name_toString(x_12, x_13); +x_15 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_16 = lean_string_append(x_15, x_14); +lean_dec(x_14); +x_17 = l_Lake_Module_recBuildLeanCToOExport___closed__1; +x_18 = lean_string_append(x_16, x_17); +x_19 = l_Lake_Module_cFacetConfig___closed__1; +lean_inc(x_1); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_1); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_21, 0, x_20); +lean_closure_set(x_21, 1, lean_box(0)); +x_22 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToONoExport___lambda__1___boxed), 9, 2); +lean_closure_set(x_22, 0, x_1); +lean_closure_set(x_22, 1, x_12); +x_23 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 2); +lean_closure_set(x_23, 0, x_21); +lean_closure_set(x_23, 1, x_22); +if (x_11 == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_string_append(x_18, x_15); +x_25 = lean_string_append(x_24, x_15); +x_26 = l_Lake_withRegisterJob___rarg(x_25, x_23, x_2, x_3, x_4, x_5, x_6, x_7); +return x_26; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_27 = l_Lake_Module_recBuildLeanCToONoExport___closed__1; +x_28 = lean_string_append(x_18, x_27); +x_29 = lean_string_append(x_28, x_15); +x_30 = l_Lake_withRegisterJob___rarg(x_29, x_23, x_2, x_3, x_4, x_5, x_6, x_7); +return x_30; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanCToONoExport___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_Module_recBuildLeanCToONoExport___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_5); +lean_dec(x_4); +return x_10; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("noexport", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Module_clearOutputHashes___closed__2; +x_2 = l_Lake_Module_coExportFacetConfig___closed__1; +x_3 = l_Lake_Module_coNoExportFacetConfig___closed__1; +x_4 = l_Lean_Name_mkStr3(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToONoExport), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_coNoExportFacetConfig___closed__3; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_coNoExportFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_coNoExportFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_coFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = l_System_Platform_isWindows; +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = l_Lake_Module_coExportFacetConfig___closed__3; +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +x_11 = lean_apply_6(x_2, x_10, x_3, x_4, x_5, x_6, x_7); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = l_Lake_Module_coNoExportFacetConfig___closed__2; +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_1); +lean_ctor_set(x_13, 1, x_12); +x_14 = lean_apply_6(x_2, x_13, x_3, x_4, x_5, x_6, x_7); +return x_14; +} +} +} +static lean_object* _init_l_Lake_Module_coFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_clearOutputHashes___closed__2; +x_2 = l_Lake_Module_coExportFacetConfig___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_coFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_coFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_coFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_coFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_coFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_coFacetConfig___closed__3; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanBcToO___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("bc.o", 4); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanBcToO___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_10 = lean_ctor_get(x_1, 0); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_11, 2); +lean_inc(x_13); +lean_dec(x_11); +x_14 = lean_ctor_get(x_13, 8); +lean_inc(x_14); +x_15 = l_System_FilePath_join(x_12, x_14); +x_16 = lean_ctor_get(x_13, 12); +lean_inc(x_16); +x_17 = l_System_FilePath_join(x_15, x_16); +x_18 = l_Lake_Module_recBuildLeanBcToO___lambda__1___closed__1; +x_19 = l_Lean_modToFilePath(x_17, x_2, x_18); +lean_dec(x_17); +x_20 = lean_ctor_get(x_13, 1); +lean_inc(x_20); +lean_dec(x_13); +x_21 = lean_ctor_get(x_20, 5); +lean_inc(x_21); +x_22 = lean_ctor_get(x_10, 1); +lean_inc(x_22); +lean_dec(x_10); +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +lean_dec(x_22); +x_24 = lean_ctor_get(x_23, 5); +lean_inc(x_24); +x_25 = l_Array_append___rarg(x_21, x_24); +lean_dec(x_24); +x_26 = lean_ctor_get_uint8(x_20, sizeof(void*)*9); +x_27 = lean_ctor_get_uint8(x_23, sizeof(void*)*9); +x_28 = l_Lake_instOrdBuildType; +x_29 = lean_box(x_26); +x_30 = lean_box(x_27); +x_31 = l_instDecidableRelLe___rarg(x_28, x_29, x_30); +x_32 = lean_ctor_get(x_20, 3); +lean_inc(x_32); +lean_dec(x_20); +x_33 = lean_ctor_get(x_23, 3); +lean_inc(x_33); +lean_dec(x_23); +x_34 = lean_ctor_get(x_3, 0); +lean_inc(x_34); +if (x_31 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = l_Lake_BuildType_leancArgs(x_27); +x_68 = l_Array_append___rarg(x_67, x_32); +lean_dec(x_32); +x_69 = l_Array_append___rarg(x_68, x_33); +lean_dec(x_33); +x_35 = x_69; +goto block_66; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = l_Lake_BuildType_leancArgs(x_26); +x_71 = l_Array_append___rarg(x_70, x_32); +lean_dec(x_32); +x_72 = l_Array_append___rarg(x_71, x_33); +lean_dec(x_33); +x_35 = x_72; +goto block_66; +} +block_66: +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; +lean_inc(x_35); +x_36 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__2___boxed), 5, 1); +lean_closure_set(x_36, 0, x_35); +x_37 = l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2; +x_38 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_38, 0, x_37); +lean_closure_set(x_38, 1, x_36); +x_39 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanCToOExport___lambda__6), 7, 5); +lean_closure_set(x_39, 0, x_25); +lean_closure_set(x_39, 1, x_35); +lean_closure_set(x_39, 2, x_19); +lean_closure_set(x_39, 3, x_38); +lean_closure_set(x_39, 4, x_6); +x_40 = l_Task_Priority_default; +x_41 = 0; +x_42 = lean_io_map_task(x_39, x_34, x_40, x_41, x_9); +if (lean_obj_tag(x_42) == 0) +{ +uint8_t x_43; +x_43 = !lean_is_exclusive(x_42); +if (x_43 == 0) +{ +uint8_t x_44; +x_44 = !lean_is_exclusive(x_3); +if (x_44 == 0) +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_45 = lean_ctor_get(x_42, 0); +x_46 = lean_ctor_get(x_3, 0); +lean_dec(x_46); +lean_ctor_set(x_3, 0, x_45); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_3); +lean_ctor_set(x_47, 1, x_7); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_8); +lean_ctor_set(x_42, 0, x_48); +return x_42; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_49 = lean_ctor_get(x_42, 0); +x_50 = lean_ctor_get(x_3, 1); +lean_inc(x_50); +lean_dec(x_3); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_7); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_8); +lean_ctor_set(x_42, 0, x_53); +return x_42; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_54 = lean_ctor_get(x_42, 0); +x_55 = lean_ctor_get(x_42, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_42); +x_56 = lean_ctor_get(x_3, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + x_57 = x_3; +} else { + lean_dec_ref(x_3); + x_57 = lean_box(0); +} +if (lean_is_scalar(x_57)) { + x_58 = lean_alloc_ctor(0, 2, 0); +} else { + x_58 = x_57; +} +lean_ctor_set(x_58, 0, x_54); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_7); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_8); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_55); +return x_61; +} +} +else +{ +uint8_t x_62; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_3); +x_62 = !lean_is_exclusive(x_42); +if (x_62 == 0) +{ +return x_42; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_42, 0); +x_64 = lean_ctor_get(x_42, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_42); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildLeanBcToO___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":bc.o", 5); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanBcToO(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = 1; +lean_inc(x_8); +x_10 = l_Lean_Name_toString(x_8, x_9); +x_11 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_12 = lean_string_append(x_11, x_10); +lean_dec(x_10); +x_13 = l_Lake_Module_recBuildLeanBcToO___closed__1; +x_14 = lean_string_append(x_12, x_13); +x_15 = l_Lake_Module_bcFacetConfig___closed__1; +lean_inc(x_1); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_15); +x_17 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, lean_box(0)); +x_18 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanBcToO___lambda__1___boxed), 9, 2); +lean_closure_set(x_18, 0, x_1); +lean_closure_set(x_18, 1, x_8); +x_19 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 2); +lean_closure_set(x_19, 0, x_17); +lean_closure_set(x_19, 1, x_18); +x_20 = l_Lake_withRegisterJob___rarg(x_14, x_19, x_2, x_3, x_4, x_5, x_6, x_7); +return x_20; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildLeanBcToO___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_Module_recBuildLeanBcToO___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_5); +lean_dec(x_4); +return x_10; +} +} +static lean_object* _init_l_Lake_Module_bcoFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_clearOutputHashes___closed__4; +x_2 = l_Lake_Module_coExportFacetConfig___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bcoFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_recBuildLeanBcToO), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_bcoFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_bcoFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_bcoFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_bcoFacetConfig___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oExportFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get_uint8(x_10, sizeof(void*)*9 + 1); +lean_dec(x_10); +x_12 = lean_ctor_get(x_8, 0); +lean_inc(x_12); +lean_dec(x_8); +x_13 = lean_ctor_get(x_12, 2); +lean_inc(x_13); +lean_dec(x_12); +x_14 = lean_ctor_get(x_13, 1); +lean_inc(x_14); +lean_dec(x_13); +x_15 = lean_ctor_get_uint8(x_14, sizeof(void*)*9 + 1); +lean_dec(x_14); +x_16 = l_Lake_Backend_orPreferLeft(x_11, x_15); +x_17 = lean_box(x_16); +if (lean_obj_tag(x_17) == 1) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = l_Lake_Module_bcoFacetConfig___closed__1; +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_1); +lean_ctor_set(x_19, 1, x_18); +x_20 = lean_apply_6(x_2, x_19, x_3, x_4, x_5, x_6, x_7); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_17); +x_21 = l_Lake_Module_coExportFacetConfig___closed__3; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_1); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_apply_6(x_2, x_22, x_3, x_4, x_5, x_6, x_7); +return x_23; +} +} +} +static lean_object* _init_l_Lake_Module_oExportFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_coExportFacetConfig___closed__1; +x_2 = l_Lake_Module_coExportFacetConfig___closed__2; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oExportFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_oExportFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oExportFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_oExportFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oExportFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oExportFacetConfig___closed__3; +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("the LLVM backend only supports exporting Lean symbols", 53); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__2() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 3; +x_2 = l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__1; +x_3 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oNoExportFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get_uint8(x_10, sizeof(void*)*9 + 1); +lean_dec(x_10); +x_12 = lean_ctor_get(x_8, 0); +lean_inc(x_12); +lean_dec(x_8); +x_13 = lean_ctor_get(x_12, 2); +lean_inc(x_13); +lean_dec(x_12); +x_14 = lean_ctor_get(x_13, 1); +lean_inc(x_14); +lean_dec(x_13); +x_15 = lean_ctor_get_uint8(x_14, sizeof(void*)*9 + 1); +lean_dec(x_14); +x_16 = l_Lake_Backend_orPreferLeft(x_11, x_15); +x_17 = lean_box(x_16); +if (lean_obj_tag(x_17) == 1) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_18 = lean_array_get_size(x_5); +x_19 = l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__2; +x_20 = lean_array_push(x_5, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_18); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_6); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_7); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +lean_dec(x_17); +x_24 = l_Lake_Module_coNoExportFacetConfig___closed__2; +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_1); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_apply_6(x_2, x_25, x_3, x_4, x_5, x_6, x_7); +return x_26; +} +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_coExportFacetConfig___closed__1; +x_2 = l_Lake_Module_coNoExportFacetConfig___closed__1; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_oNoExportFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_oNoExportFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oNoExportFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oNoExportFacetConfig___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_oFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get_uint8(x_10, sizeof(void*)*9 + 1); +lean_dec(x_10); +x_12 = lean_ctor_get(x_8, 0); +lean_inc(x_12); +lean_dec(x_8); +x_13 = lean_ctor_get(x_12, 2); +lean_inc(x_13); +lean_dec(x_12); +x_14 = lean_ctor_get(x_13, 1); +lean_inc(x_14); +lean_dec(x_13); +x_15 = lean_ctor_get_uint8(x_14, sizeof(void*)*9 + 1); +lean_dec(x_14); +x_16 = l_Lake_Backend_orPreferLeft(x_11, x_15); +x_17 = lean_box(x_16); +if (lean_obj_tag(x_17) == 1) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = l_Lake_Module_bcoFacetConfig___closed__1; +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_1); +lean_ctor_set(x_19, 1, x_18); +x_20 = lean_apply_6(x_2, x_19, x_3, x_4, x_5, x_6, x_7); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_17); +x_21 = l_Lake_Module_coFacetConfig___closed__1; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_1); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_apply_6(x_2, x_22, x_3, x_4, x_5, x_6, x_7); +return x_23; +} +} +} +static lean_object* _init_l_Lake_Module_oFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Module_coExportFacetConfig___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_oFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_oFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_oFacetConfig___closed__2; +x_2 = l_Lake_Module_oleanFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_oFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_oFacetConfig___closed__3; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__1(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; +x_11 = lean_usize_dec_lt(x_3, x_2); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_4); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_10); +return x_14; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_15 = lean_array_uget(x_4, x_3); +x_16 = lean_unsigned_to_nat(0u); +x_17 = lean_array_uset(x_4, x_3, x_16); +lean_inc(x_1); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_1); +lean_ctor_set(x_18, 1, x_15); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_19 = lean_apply_6(x_5, x_18, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; size_t x_26; size_t x_27; lean_object* x_28; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = lean_ctor_get(x_20, 1); +lean_inc(x_23); +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_21, 1); +lean_inc(x_25); +lean_dec(x_21); +x_26 = 1; +x_27 = lean_usize_add(x_3, x_26); +x_28 = lean_array_uset(x_17, x_3, x_24); +x_3 = x_27; +x_4 = x_28; +x_8 = x_25; +x_9 = x_23; +x_10 = x_22; +goto _start; +} +else +{ +uint8_t x_30; +lean_dec(x_17); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_30 = !lean_is_exclusive(x_19); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_19, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_20); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_20, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_21); +if (x_34 == 0) +{ +return x_19; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_21, 0); +x_36 = lean_ctor_get(x_21, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_21); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +lean_ctor_set(x_20, 0, x_37); +return x_19; +} +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_20, 1); +lean_inc(x_38); +lean_dec(x_20); +x_39 = lean_ctor_get(x_21, 0); +lean_inc(x_39); +x_40 = lean_ctor_get(x_21, 1); +lean_inc(x_40); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_41 = x_21; +} else { + lean_dec_ref(x_21); + x_41 = lean_box(0); +} +if (lean_is_scalar(x_41)) { + x_42 = lean_alloc_ctor(1, 2, 0); +} else { + x_42 = x_41; +} +lean_ctor_set(x_42, 0, x_39); +lean_ctor_set(x_42, 1, x_40); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_38); +lean_ctor_set(x_19, 0, x_43); +return x_19; +} +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_19, 1); +lean_inc(x_44); +lean_dec(x_19); +x_45 = lean_ctor_get(x_20, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_46 = x_20; +} else { + lean_dec_ref(x_20); + x_46 = lean_box(0); +} +x_47 = lean_ctor_get(x_21, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_21, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_49 = x_21; +} else { + lean_dec_ref(x_21); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +if (lean_is_scalar(x_46)) { + x_51 = lean_alloc_ctor(0, 2, 0); +} else { + x_51 = x_46; +} +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_45); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_44); +return x_52; +} +} +} +else +{ +uint8_t x_53; +lean_dec(x_17); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_53 = !lean_is_exclusive(x_19); +if (x_53 == 0) +{ +return x_19; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_19, 0); +x_55 = lean_ctor_get(x_19, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_19); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__2(size_t x_1, size_t x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = lean_usize_dec_lt(x_2, x_1); +if (x_4 == 0) +{ +return x_3; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; size_t x_9; size_t x_10; lean_object* x_11; +x_5 = lean_array_uget(x_3, x_2); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_uset(x_3, x_2, x_6); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_dec(x_5); +x_9 = 1; +x_10 = lean_usize_add(x_2, x_9); +x_11 = lean_array_uset(x_7, x_2, x_8); +x_2 = x_10; +x_3 = x_11; +goto _start; +} +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-L", 2); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3(size_t x_1, size_t x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = lean_usize_dec_lt(x_2, x_1); +if (x_4 == 0) +{ +return x_3; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; size_t x_12; size_t x_13; lean_object* x_14; +x_5 = lean_array_uget(x_3, x_2); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_uset(x_3, x_2, x_6); +x_8 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___closed__1; +x_9 = lean_string_append(x_8, x_5); +lean_dec(x_5); +x_10 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_11 = lean_string_append(x_9, x_10); +x_12 = 1; +x_13 = lean_usize_add(x_2, x_12); +x_14 = lean_array_uset(x_7, x_2, x_11); +x_2 = x_13; +x_3 = x_14; +goto _start; +} +} +} +static lean_object* _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-l", 2); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4(size_t x_1, size_t x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = lean_usize_dec_lt(x_2, x_1); +if (x_4 == 0) +{ +return x_3; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; size_t x_12; size_t x_13; lean_object* x_14; +x_5 = lean_array_uget(x_3, x_2); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_array_uset(x_3, x_2, x_6); +x_8 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___closed__1; +x_9 = lean_string_append(x_8, x_5); +lean_dec(x_5); +x_10 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_11 = lean_string_append(x_9, x_10); +x_12 = 1; +x_13 = lean_usize_add(x_2, x_12); +x_14 = lean_array_uset(x_7, x_2, x_11); +x_2 = x_13; +x_3 = x_14; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_5, 0); +x_9 = l_Lake_compileSharedLib(x_1, x_2, x_3, x_8, x_6); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_9); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_9, 0); +lean_dec(x_12); +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_14); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_10, 0); +x_16 = lean_ctor_get(x_10, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_5); +lean_ctor_set(x_9, 0, x_17); +return x_9; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_18 = lean_ctor_get(x_9, 1); +lean_inc(x_18); +lean_dec(x_9); +x_19 = lean_ctor_get(x_10, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_10, 1); +lean_inc(x_20); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_21 = x_10; +} else { + lean_dec_ref(x_10); + x_21 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_20); +if (lean_is_scalar(x_21)) { + x_22 = lean_alloc_ctor(0, 2, 0); +} else { + x_22 = x_21; +} +lean_ctor_set(x_22, 0, x_19); +lean_ctor_set(x_22, 1, x_5); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_18); +return x_23; +} +} +else +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_9); +if (x_24 == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_9, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_10); +if (x_26 == 0) +{ +lean_object* x_27; +x_27 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_27); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_10, 0); +x_29 = lean_ctor_get(x_10, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_29); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_5); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_10, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_34 = x_10; +} else { + lean_dec_ref(x_10); + x_34 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_33); +if (lean_is_scalar(x_34)) { + x_35 = lean_alloc_ctor(1, 2, 0); +} else { + x_35 = x_34; +} +lean_ctor_set(x_35, 0, x_32); +lean_ctor_set(x_35, 1, x_5); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_31); +return x_36; +} +} +} +else +{ +lean_object* x_37; uint8_t x_38; lean_object* x_39; lean_object* x_40; +x_37 = lean_ctor_get(x_5, 0); +x_38 = lean_ctor_get_uint8(x_5, sizeof(void*)*1); +lean_inc(x_37); +lean_dec(x_5); +x_39 = l_Lake_compileSharedLib(x_1, x_2, x_3, x_37, x_6); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_41 = lean_ctor_get(x_39, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_42 = x_39; +} else { + lean_dec_ref(x_39); + x_42 = lean_box(0); +} +x_43 = lean_ctor_get(x_40, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_40, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_45 = x_40; +} else { + lean_dec_ref(x_40); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_43); +lean_ctor_set(x_47, 1, x_46); +if (lean_is_scalar(x_42)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_42; +} +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_41); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_49 = lean_ctor_get(x_39, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_50 = x_39; +} else { + lean_dec_ref(x_39); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_40, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_40, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_53 = x_40; +} else { + lean_dec_ref(x_40); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_53)) { + x_55 = lean_alloc_ctor(1, 2, 0); +} else { + x_55 = x_53; +} +lean_ctor_set(x_55, 0, x_51); +lean_ctor_set(x_55, 1, x_54); +if (lean_is_scalar(x_50)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_50; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +return x_56; +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildDynlib___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-", 1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, size_t x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +_start: +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint64_t x_21; uint64_t x_22; uint64_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; size_t x_44; lean_object* x_45; lean_object* x_46; size_t x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; size_t x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_15 = lean_ctor_get(x_1, 2); +lean_inc(x_15); +x_16 = lean_ctor_get(x_15, 1); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 6); +lean_inc(x_17); +x_18 = lean_ctor_get(x_2, 0); +x_19 = lean_ctor_get(x_18, 6); +x_20 = l_Array_append___rarg(x_17, x_19); +x_21 = l_Lake_computeArrayHash___at_Lake_buildO___spec__1(x_20); +x_22 = l_Lake_platformTrace; +x_23 = lean_uint64_mix_hash(x_21, x_22); +x_24 = l_Lake_Module_recBuildDeps___lambda__1___closed__2; +x_25 = lean_box_uint64(x_23); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_24); +x_27 = l_Lake_BuildTrace_mix(x_11, x_26); +x_28 = l_Lake_BuildTrace_mix(x_3, x_27); +x_29 = l_Lake_BuildTrace_mix(x_4, x_28); +x_30 = l_Lake_BuildTrace_mix(x_5, x_29); +x_31 = lean_ctor_get(x_1, 0); +lean_inc(x_31); +lean_dec(x_1); +x_32 = lean_ctor_get(x_15, 8); +lean_inc(x_32); +x_33 = l_System_FilePath_join(x_31, x_32); +x_34 = lean_ctor_get(x_15, 10); +lean_inc(x_34); +lean_dec(x_15); +x_35 = l_System_FilePath_join(x_33, x_34); +x_36 = l_Lake_Module_recBuildDynlib___lambda__2___closed__1; +x_37 = 1; +x_38 = l_Lean_Name_toStringWithSep(x_36, x_37, x_6); +x_39 = l_Lake_Module_dynlibSuffix; +x_40 = lean_string_append(x_38, x_39); +x_41 = l_Lake_nameToSharedLib(x_40); +x_42 = l_System_FilePath_join(x_35, x_41); +x_43 = lean_array_get_size(x_7); +x_44 = lean_usize_of_nat(x_43); +lean_dec(x_43); +x_45 = l_Array_mapMUnsafe_map___at_Lake_compileStaticLib___spec__1(x_44, x_8, x_7); +x_46 = lean_array_get_size(x_9); +x_47 = lean_usize_of_nat(x_46); +lean_dec(x_46); +x_48 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3(x_47, x_8, x_9); +x_49 = l_Array_append___rarg(x_45, x_48); +lean_dec(x_48); +x_50 = lean_array_get_size(x_10); +x_51 = lean_usize_of_nat(x_50); +lean_dec(x_50); +x_52 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4(x_51, x_8, x_10); +x_53 = l_Array_append___rarg(x_49, x_52); +lean_dec(x_52); +x_54 = lean_ctor_get(x_16, 7); +lean_inc(x_54); +lean_dec(x_16); +x_55 = lean_ctor_get(x_18, 7); +x_56 = l_Array_append___rarg(x_54, x_55); +x_57 = l_Array_append___rarg(x_53, x_56); +lean_dec(x_56); +x_58 = l_Array_append___rarg(x_57, x_20); +lean_dec(x_20); +lean_inc(x_42); +x_59 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__1___boxed), 6, 2); +lean_closure_set(x_59, 0, x_42); +lean_closure_set(x_59, 1, x_58); +x_60 = l_Lake_Module_recBuildLeanCToOExport___lambda__5___closed__1; +x_61 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_61, 0, x_60); +lean_closure_set(x_61, 1, x_59); +lean_inc(x_42); +x_62 = l_Lake_buildFileUnlessUpToDate(x_42, x_30, x_61, x_12, x_13, x_14); +if (lean_obj_tag(x_62) == 0) +{ +lean_object* x_63; +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +if (lean_obj_tag(x_63) == 0) +{ +uint8_t x_64; +x_64 = !lean_is_exclusive(x_62); +if (x_64 == 0) +{ +lean_object* x_65; uint8_t x_66; +x_65 = lean_ctor_get(x_62, 0); +lean_dec(x_65); +x_66 = !lean_is_exclusive(x_63); +if (x_66 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_63, 0); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_42); +lean_ctor_set(x_68, 1, x_40); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_67); +lean_ctor_set(x_63, 0, x_69); +return x_62; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_70 = lean_ctor_get(x_63, 0); +x_71 = lean_ctor_get(x_63, 1); +lean_inc(x_71); +lean_inc(x_70); +lean_dec(x_63); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_42); +lean_ctor_set(x_72, 1, x_40); +x_73 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_70); +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_71); +lean_ctor_set(x_62, 0, x_74); +return x_62; +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_75 = lean_ctor_get(x_62, 1); +lean_inc(x_75); +lean_dec(x_62); +x_76 = lean_ctor_get(x_63, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_63, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_78 = x_63; +} else { + lean_dec_ref(x_63); + x_78 = lean_box(0); +} +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_42); +lean_ctor_set(x_79, 1, x_40); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_76); +if (lean_is_scalar(x_78)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_78; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_77); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_75); +return x_82; +} +} +else +{ +uint8_t x_83; +lean_dec(x_42); +lean_dec(x_40); +x_83 = !lean_is_exclusive(x_62); +if (x_83 == 0) +{ +lean_object* x_84; uint8_t x_85; +x_84 = lean_ctor_get(x_62, 0); +lean_dec(x_84); +x_85 = !lean_is_exclusive(x_63); +if (x_85 == 0) +{ +return x_62; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_86 = lean_ctor_get(x_63, 0); +x_87 = lean_ctor_get(x_63, 1); +lean_inc(x_87); +lean_inc(x_86); +lean_dec(x_63); +x_88 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_88, 0, x_86); +lean_ctor_set(x_88, 1, x_87); +lean_ctor_set(x_62, 0, x_88); +return x_62; +} +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_89 = lean_ctor_get(x_62, 1); +lean_inc(x_89); +lean_dec(x_62); +x_90 = lean_ctor_get(x_63, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_63, 1); +lean_inc(x_91); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_92 = x_63; +} else { + lean_dec_ref(x_63); + x_92 = lean_box(0); +} +if (lean_is_scalar(x_92)) { + x_93 = lean_alloc_ctor(1, 2, 0); +} else { + x_93 = x_92; +} +lean_ctor_set(x_93, 0, x_90); +lean_ctor_set(x_93, 1, x_91); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_89); +return x_94; +} +} +} +else +{ +uint8_t x_95; +lean_dec(x_42); +lean_dec(x_40); +x_95 = !lean_is_exclusive(x_62); +if (x_95 == 0) +{ +return x_62; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_62, 0); +x_97 = lean_ctor_get(x_62, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_62); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +return x_98; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__3(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; size_t x_18; lean_object* x_19; lean_object* x_20; size_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +lean_dec(x_11); +x_15 = lean_ctor_get(x_13, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_13, 1); +lean_inc(x_16); +lean_dec(x_13); +x_17 = lean_array_get_size(x_1); +x_18 = lean_usize_of_nat(x_17); +lean_dec(x_17); +x_19 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__2(x_18, x_2, x_1); +x_20 = lean_array_get_size(x_15); +x_21 = lean_usize_of_nat(x_20); +lean_inc(x_15); +x_22 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__2(x_21, x_2, x_15); +x_23 = l_Array_append___rarg(x_19, x_22); +lean_dec(x_22); +x_24 = lean_unsigned_to_nat(0u); +x_25 = l_Array_filterMapM___at_Lake_Module_recBuildDeps___spec__12(x_15, x_24, x_20); +lean_dec(x_20); +lean_dec(x_15); +x_26 = l_Array_append___rarg(x_3, x_25); +lean_dec(x_25); +x_27 = lean_box_usize(x_2); +x_28 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__2___boxed), 14, 10); +lean_closure_set(x_28, 0, x_4); +lean_closure_set(x_28, 1, x_5); +lean_closure_set(x_28, 2, x_16); +lean_closure_set(x_28, 3, x_6); +lean_closure_set(x_28, 4, x_7); +lean_closure_set(x_28, 5, x_8); +lean_closure_set(x_28, 6, x_9); +lean_closure_set(x_28, 7, x_27); +lean_closure_set(x_28, 8, x_26); +lean_closure_set(x_28, 9, x_23); +x_29 = l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2; +x_30 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_30, 0, x_29); +lean_closure_set(x_30, 1, x_28); +x_31 = 1; +lean_inc(x_10); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_computeDynlibOfShared___spec__1(x_30, x_31, x_10, x_14, x_12); +if (lean_obj_tag(x_32) == 0) +{ +lean_object* x_33; +x_33 = lean_ctor_get(x_32, 0); +lean_inc(x_33); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_32, 1); +lean_inc(x_35); +lean_dec(x_32); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = lean_ctor_get(x_34, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_34, 1); +lean_inc(x_38); +lean_dec(x_34); +x_39 = l_String_isEmpty(x_37); +if (x_39 == 0) +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; lean_object* x_45; uint8_t x_46; +x_40 = l_Lake_Module_recBuildLean___lambda__5___closed__1; +x_41 = lean_string_append(x_40, x_37); +lean_dec(x_37); +x_42 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_43 = lean_string_append(x_41, x_42); +x_44 = 1; +x_45 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set_uint8(x_45, sizeof(void*)*1, x_44); +x_46 = !lean_is_exclusive(x_36); +if (x_46 == 0) +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_47 = lean_ctor_get(x_36, 0); +x_48 = lean_array_push(x_47, x_45); +lean_ctor_set(x_36, 0, x_48); +x_49 = lean_box(0); +x_50 = l_Lake_Module_recBuildLean___lambda__4(x_38, x_49, x_10, x_36, x_35); +lean_dec(x_10); +return x_50; +} +else +{ +lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_51 = lean_ctor_get(x_36, 0); +x_52 = lean_ctor_get_uint8(x_36, sizeof(void*)*1); +lean_inc(x_51); +lean_dec(x_36); +x_53 = lean_array_push(x_51, x_45); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_52); +x_55 = lean_box(0); +x_56 = l_Lake_Module_recBuildLean___lambda__4(x_38, x_55, x_10, x_54, x_35); +lean_dec(x_10); +return x_56; +} +} +else +{ +lean_object* x_57; lean_object* x_58; +lean_dec(x_37); +x_57 = lean_box(0); +x_58 = l_Lake_Module_recBuildLean___lambda__4(x_38, x_57, x_10, x_36, x_35); +lean_dec(x_10); +return x_58; +} +} +else +{ +uint8_t x_59; +lean_dec(x_10); +x_59 = !lean_is_exclusive(x_32); +if (x_59 == 0) +{ +lean_object* x_60; uint8_t x_61; +x_60 = lean_ctor_get(x_32, 0); +lean_dec(x_60); +x_61 = !lean_is_exclusive(x_33); +if (x_61 == 0) +{ +return x_32; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_62 = lean_ctor_get(x_33, 0); +x_63 = lean_ctor_get(x_33, 1); +lean_inc(x_63); +lean_inc(x_62); +lean_dec(x_33); +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set(x_64, 1, x_63); +lean_ctor_set(x_32, 0, x_64); +return x_32; +} +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_65 = lean_ctor_get(x_32, 1); +lean_inc(x_65); +lean_dec(x_32); +x_66 = lean_ctor_get(x_33, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_33, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_68 = x_33; +} else { + lean_dec_ref(x_33); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_65); +return x_70; +} +} +} +else +{ +uint8_t x_71; +lean_dec(x_10); +x_71 = !lean_is_exclusive(x_32); +if (x_71 == 0) +{ +return x_32; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_72 = lean_ctor_get(x_32, 0); +x_73 = lean_ctor_get(x_32, 1); +lean_inc(x_73); +lean_inc(x_72); +lean_dec(x_32); +x_74 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_74, 0, x_72); +lean_ctor_set(x_74, 1, x_73); +return x_74; +} +} +} +else +{ +uint8_t x_75; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_75 = !lean_is_exclusive(x_11); +if (x_75 == 0) +{ +lean_object* x_76; +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_11); +lean_ctor_set(x_76, 1, x_12); +return x_76; +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_77 = lean_ctor_get(x_11, 0); +x_78 = lean_ctor_get(x_11, 1); +lean_inc(x_78); +lean_inc(x_77); +lean_dec(x_11); +x_79 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_79, 0, x_77); +lean_ctor_set(x_79, 1, x_78); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_12); +return x_80; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__4(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_12, 1); +lean_inc(x_15); +lean_dec(x_12); +x_16 = lean_ctor_get(x_1, 0); +lean_inc(x_16); +lean_dec(x_1); +x_17 = lean_box_usize(x_2); +x_18 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__3___boxed), 12, 10); +lean_closure_set(x_18, 0, x_14); +lean_closure_set(x_18, 1, x_17); +lean_closure_set(x_18, 2, x_3); +lean_closure_set(x_18, 3, x_4); +lean_closure_set(x_18, 4, x_5); +lean_closure_set(x_18, 5, x_15); +lean_closure_set(x_18, 6, x_6); +lean_closure_set(x_18, 7, x_7); +lean_closure_set(x_18, 8, x_8); +lean_closure_set(x_18, 9, x_9); +x_19 = l_Task_Priority_default; +x_20 = 0; +x_21 = lean_io_map_task(x_18, x_16, x_19, x_20, x_11); +if (lean_obj_tag(x_21) == 0) +{ +uint8_t x_22; +x_22 = !lean_is_exclusive(x_21); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_21, 0); +x_24 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_24, 0, x_13); +x_25 = 1; +x_26 = lean_task_map(x_24, x_23, x_19, x_25); +lean_ctor_set(x_21, 0, x_26); +return x_21; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; +x_27 = lean_ctor_get(x_21, 0); +x_28 = lean_ctor_get(x_21, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_21); +x_29 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_29, 0, x_13); +x_30 = 1; +x_31 = lean_task_map(x_29, x_27, x_19, x_30); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_28); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_dec(x_13); +x_33 = !lean_is_exclusive(x_21); +if (x_33 == 0) +{ +return x_21; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_21, 0); +x_35 = lean_ctor_get(x_21, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_21); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +else +{ +uint8_t x_37; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_37 = !lean_is_exclusive(x_10); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +x_38 = lean_task_pure(x_10); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_11); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_40 = lean_ctor_get(x_10, 0); +x_41 = lean_ctor_get(x_10, 1); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_10); +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +x_43 = lean_task_pure(x_42); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_11); +return x_44; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__5(lean_object* x_1, lean_object* x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +lean_dec(x_11); +x_15 = lean_ctor_get(x_1, 0); +lean_inc(x_15); +lean_dec(x_1); +x_16 = lean_box_usize(x_3); +x_17 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__4___boxed), 11, 9); +lean_closure_set(x_17, 0, x_2); +lean_closure_set(x_17, 1, x_16); +lean_closure_set(x_17, 2, x_4); +lean_closure_set(x_17, 3, x_5); +lean_closure_set(x_17, 4, x_6); +lean_closure_set(x_17, 5, x_14); +lean_closure_set(x_17, 6, x_7); +lean_closure_set(x_17, 7, x_13); +lean_closure_set(x_17, 8, x_8); +x_18 = l_Task_Priority_default; +x_19 = 0; +x_20 = lean_io_bind_task(x_15, x_17, x_18, x_19, x_10); +if (lean_obj_tag(x_20) == 0) +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_20); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_20, 0); +x_23 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_23, 0, x_12); +x_24 = 1; +x_25 = lean_task_map(x_23, x_22, x_18, x_24); +lean_ctor_set(x_20, 0, x_25); +return x_20; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; lean_object* x_30; lean_object* x_31; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_ctor_get(x_20, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_20); +x_28 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDeps___lambda__2), 2, 1); +lean_closure_set(x_28, 0, x_12); +x_29 = 1; +x_30 = lean_task_map(x_28, x_26, x_18, x_29); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_27); +return x_31; +} +} +else +{ +uint8_t x_32; +lean_dec(x_12); +x_32 = !lean_is_exclusive(x_20); +if (x_32 == 0) +{ +return x_20; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_20, 0); +x_34 = lean_ctor_get(x_20, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_20); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +return x_35; +} +} +} +else +{ +uint8_t x_36; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_36 = !lean_is_exclusive(x_9); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; +x_37 = lean_task_pure(x_9); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_10); +return x_38; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_39 = lean_ctor_get(x_9, 0); +x_40 = lean_ctor_get(x_9, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_9); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_40); +x_42 = lean_task_pure(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1() { +_start: +{ +size_t x_1; lean_object* x_2; +x_1 = 0; +x_2 = lean_box_usize(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; size_t x_11; size_t x_12; lean_object* x_13; +x_10 = lean_array_get_size(x_3); +x_11 = lean_usize_of_nat(x_10); +x_12 = 0; +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_3); +x_13 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2(x_11, x_12, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_16 = lean_ctor_get(x_13, 1); +lean_inc(x_16); +lean_dec(x_13); +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_ctor_get(x_15, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_15, 1); +lean_inc(x_19); +lean_dec(x_15); +x_20 = lean_unsigned_to_nat(0u); +x_21 = lean_nat_dec_lt(x_20, x_10); +x_22 = lean_ctor_get(x_1, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_22, 0); +lean_inc(x_23); +if (x_21 == 0) +{ +lean_object* x_193; +lean_dec(x_10); +lean_dec(x_3); +x_193 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_24 = x_193; +goto block_192; +} +else +{ +uint8_t x_194; +x_194 = lean_nat_dec_le(x_10, x_10); +lean_dec(x_10); +if (x_194 == 0) +{ +lean_object* x_195; +lean_dec(x_3); +x_195 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_24 = x_195; +goto block_192; +} +else +{ +lean_object* x_196; lean_object* x_197; +x_196 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_197 = l_Array_foldlMUnsafe_fold___at_Lake_Module_recBuildDeps___spec__15(x_3, x_12, x_11, x_196); +lean_dec(x_3); +x_24 = x_197; +goto block_192; +} +} +block_192: +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_inc(x_23); +x_25 = l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3(x_24, x_23); +x_26 = lean_ctor_get(x_25, 1); +lean_inc(x_26); +lean_dec(x_25); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +x_27 = l_Lake_recBuildExternDynlibs(x_26, x_4, x_5, x_6, x_19, x_17, x_16); +lean_dec(x_26); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; size_t x_42; lean_object* x_43; +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +x_31 = lean_ctor_get(x_27, 1); +lean_inc(x_31); +lean_dec(x_27); +x_32 = lean_ctor_get(x_28, 1); +lean_inc(x_32); +lean_dec(x_28); +x_33 = lean_ctor_get(x_29, 1); +lean_inc(x_33); +lean_dec(x_29); +x_34 = lean_ctor_get(x_30, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_30, 1); +lean_inc(x_35); +lean_dec(x_30); +x_36 = lean_ctor_get(x_22, 1); +lean_inc(x_36); +lean_dec(x_22); +x_37 = lean_ctor_get(x_36, 8); +lean_inc(x_37); +x_38 = 1; +x_39 = lean_box(x_38); +x_40 = lean_apply_1(x_37, x_39); +x_41 = lean_array_get_size(x_40); +x_42 = lean_usize_of_nat(x_41); +lean_dec(x_41); +lean_inc(x_6); +x_43 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__1(x_1, x_42, x_12, x_40, x_4, x_5, x_6, x_33, x_32, x_31); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; lean_object* x_45; +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_44, 0); +lean_inc(x_45); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; uint8_t x_47; +x_46 = lean_ctor_get(x_43, 1); +lean_inc(x_46); +lean_dec(x_43); +x_47 = !lean_is_exclusive(x_44); +if (x_47 == 0) +{ +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_44, 1); +x_49 = lean_ctor_get(x_44, 0); +lean_dec(x_49); +x_50 = !lean_is_exclusive(x_45); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_51 = lean_ctor_get(x_45, 0); +x_52 = lean_ctor_get(x_45, 1); +x_53 = l_Lake_BuildJob_collectArray___rarg(x_51); +lean_dec(x_51); +x_54 = l_Lake_BuildJob_collectArray___rarg(x_18); +lean_dec(x_18); +x_55 = l_Lake_BuildJob_collectArray___rarg(x_34); +lean_dec(x_34); +x_56 = !lean_is_exclusive(x_53); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; +x_57 = lean_ctor_get(x_53, 0); +x_58 = lean_ctor_get(x_53, 1); +x_59 = l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1; +x_60 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__5___boxed), 10, 8); +lean_closure_set(x_60, 0, x_54); +lean_closure_set(x_60, 1, x_55); +lean_closure_set(x_60, 2, x_59); +lean_closure_set(x_60, 3, x_35); +lean_closure_set(x_60, 4, x_23); +lean_closure_set(x_60, 5, x_36); +lean_closure_set(x_60, 6, x_2); +lean_closure_set(x_60, 7, x_6); +x_61 = l_Task_Priority_default; +x_62 = 0; +x_63 = lean_io_bind_task(x_57, x_60, x_61, x_62, x_46); +if (lean_obj_tag(x_63) == 0) +{ +uint8_t x_64; +x_64 = !lean_is_exclusive(x_63); +if (x_64 == 0) +{ +lean_object* x_65; +x_65 = lean_ctor_get(x_63, 0); +lean_ctor_set(x_53, 0, x_65); +lean_ctor_set(x_45, 0, x_53); +lean_ctor_set(x_63, 0, x_44); +return x_63; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_63, 0); +x_67 = lean_ctor_get(x_63, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_63); +lean_ctor_set(x_53, 0, x_66); +lean_ctor_set(x_45, 0, x_53); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_44); +lean_ctor_set(x_68, 1, x_67); +return x_68; +} +} +else +{ +uint8_t x_69; +lean_free_object(x_53); +lean_dec(x_58); +lean_free_object(x_45); +lean_dec(x_52); +lean_free_object(x_44); +lean_dec(x_48); +x_69 = !lean_is_exclusive(x_63); +if (x_69 == 0) +{ +return x_63; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_63, 0); +x_71 = lean_ctor_get(x_63, 1); +lean_inc(x_71); +lean_inc(x_70); +lean_dec(x_63); +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; +} +} +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; +x_73 = lean_ctor_get(x_53, 0); +x_74 = lean_ctor_get(x_53, 1); +lean_inc(x_74); +lean_inc(x_73); +lean_dec(x_53); +x_75 = l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1; +x_76 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__5___boxed), 10, 8); +lean_closure_set(x_76, 0, x_54); +lean_closure_set(x_76, 1, x_55); +lean_closure_set(x_76, 2, x_75); +lean_closure_set(x_76, 3, x_35); +lean_closure_set(x_76, 4, x_23); +lean_closure_set(x_76, 5, x_36); +lean_closure_set(x_76, 6, x_2); +lean_closure_set(x_76, 7, x_6); +x_77 = l_Task_Priority_default; +x_78 = 0; +x_79 = lean_io_bind_task(x_73, x_76, x_77, x_78, x_46); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_79, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_82 = x_79; +} else { + lean_dec_ref(x_79); + x_82 = lean_box(0); +} +x_83 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_74); +lean_ctor_set(x_45, 0, x_83); +if (lean_is_scalar(x_82)) { + x_84 = lean_alloc_ctor(0, 2, 0); +} else { + x_84 = x_82; +} +lean_ctor_set(x_84, 0, x_44); +lean_ctor_set(x_84, 1, x_81); +return x_84; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; +lean_dec(x_74); +lean_free_object(x_45); +lean_dec(x_52); +lean_free_object(x_44); +lean_dec(x_48); +x_85 = lean_ctor_get(x_79, 0); +lean_inc(x_85); +x_86 = lean_ctor_get(x_79, 1); +lean_inc(x_86); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_87 = x_79; +} else { + lean_dec_ref(x_79); + x_87 = lean_box(0); +} +if (lean_is_scalar(x_87)) { + x_88 = lean_alloc_ctor(1, 2, 0); +} else { + x_88 = x_87; +} +lean_ctor_set(x_88, 0, x_85); +lean_ctor_set(x_88, 1, x_86); +return x_88; +} +} +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; lean_object* x_101; +x_89 = lean_ctor_get(x_45, 0); +x_90 = lean_ctor_get(x_45, 1); +lean_inc(x_90); +lean_inc(x_89); +lean_dec(x_45); +x_91 = l_Lake_BuildJob_collectArray___rarg(x_89); +lean_dec(x_89); +x_92 = l_Lake_BuildJob_collectArray___rarg(x_18); +lean_dec(x_18); +x_93 = l_Lake_BuildJob_collectArray___rarg(x_34); +lean_dec(x_34); +x_94 = lean_ctor_get(x_91, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_91, 1); +lean_inc(x_95); +if (lean_is_exclusive(x_91)) { + lean_ctor_release(x_91, 0); + lean_ctor_release(x_91, 1); + x_96 = x_91; +} else { + lean_dec_ref(x_91); + x_96 = lean_box(0); +} +x_97 = l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1; +x_98 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__5___boxed), 10, 8); +lean_closure_set(x_98, 0, x_92); +lean_closure_set(x_98, 1, x_93); +lean_closure_set(x_98, 2, x_97); +lean_closure_set(x_98, 3, x_35); +lean_closure_set(x_98, 4, x_23); +lean_closure_set(x_98, 5, x_36); +lean_closure_set(x_98, 6, x_2); +lean_closure_set(x_98, 7, x_6); +x_99 = l_Task_Priority_default; +x_100 = 0; +x_101 = lean_io_bind_task(x_94, x_98, x_99, x_100, x_46); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_101, 0); +lean_inc(x_102); +x_103 = lean_ctor_get(x_101, 1); +lean_inc(x_103); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_104 = x_101; +} else { + lean_dec_ref(x_101); + x_104 = lean_box(0); +} +if (lean_is_scalar(x_96)) { + x_105 = lean_alloc_ctor(0, 2, 0); +} else { + x_105 = x_96; +} +lean_ctor_set(x_105, 0, x_102); +lean_ctor_set(x_105, 1, x_95); +x_106 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_106, 0, x_105); +lean_ctor_set(x_106, 1, x_90); +lean_ctor_set(x_44, 0, x_106); +if (lean_is_scalar(x_104)) { + x_107 = lean_alloc_ctor(0, 2, 0); +} else { + x_107 = x_104; +} +lean_ctor_set(x_107, 0, x_44); +lean_ctor_set(x_107, 1, x_103); +return x_107; +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +lean_dec(x_96); +lean_dec(x_95); +lean_dec(x_90); +lean_free_object(x_44); +lean_dec(x_48); +x_108 = lean_ctor_get(x_101, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_101, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_110 = x_101; +} else { + lean_dec_ref(x_101); + x_110 = lean_box(0); +} +if (lean_is_scalar(x_110)) { + x_111 = lean_alloc_ctor(1, 2, 0); +} else { + x_111 = x_110; +} +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_109); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; uint8_t x_125; lean_object* x_126; +x_112 = lean_ctor_get(x_44, 1); +lean_inc(x_112); +lean_dec(x_44); +x_113 = lean_ctor_get(x_45, 0); +lean_inc(x_113); +x_114 = lean_ctor_get(x_45, 1); +lean_inc(x_114); +if (lean_is_exclusive(x_45)) { + lean_ctor_release(x_45, 0); + lean_ctor_release(x_45, 1); + x_115 = x_45; +} else { + lean_dec_ref(x_45); + x_115 = lean_box(0); +} +x_116 = l_Lake_BuildJob_collectArray___rarg(x_113); +lean_dec(x_113); +x_117 = l_Lake_BuildJob_collectArray___rarg(x_18); +lean_dec(x_18); +x_118 = l_Lake_BuildJob_collectArray___rarg(x_34); +lean_dec(x_34); +x_119 = lean_ctor_get(x_116, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_116, 1); +lean_inc(x_120); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + lean_ctor_release(x_116, 1); + x_121 = x_116; +} else { + lean_dec_ref(x_116); + x_121 = lean_box(0); +} +x_122 = l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1; +x_123 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__5___boxed), 10, 8); +lean_closure_set(x_123, 0, x_117); +lean_closure_set(x_123, 1, x_118); +lean_closure_set(x_123, 2, x_122); +lean_closure_set(x_123, 3, x_35); +lean_closure_set(x_123, 4, x_23); +lean_closure_set(x_123, 5, x_36); +lean_closure_set(x_123, 6, x_2); +lean_closure_set(x_123, 7, x_6); +x_124 = l_Task_Priority_default; +x_125 = 0; +x_126 = lean_io_bind_task(x_119, x_123, x_124, x_125, x_46); +if (lean_obj_tag(x_126) == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; +x_127 = lean_ctor_get(x_126, 0); +lean_inc(x_127); +x_128 = lean_ctor_get(x_126, 1); +lean_inc(x_128); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_129 = x_126; +} else { + lean_dec_ref(x_126); + x_129 = lean_box(0); +} +if (lean_is_scalar(x_121)) { + x_130 = lean_alloc_ctor(0, 2, 0); +} else { + x_130 = x_121; +} +lean_ctor_set(x_130, 0, x_127); +lean_ctor_set(x_130, 1, x_120); +if (lean_is_scalar(x_115)) { + x_131 = lean_alloc_ctor(0, 2, 0); +} else { + x_131 = x_115; +} +lean_ctor_set(x_131, 0, x_130); +lean_ctor_set(x_131, 1, x_114); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_112); +if (lean_is_scalar(x_129)) { + x_133 = lean_alloc_ctor(0, 2, 0); +} else { + x_133 = x_129; +} +lean_ctor_set(x_133, 0, x_132); +lean_ctor_set(x_133, 1, x_128); +return x_133; +} +else +{ +lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +lean_dec(x_121); +lean_dec(x_120); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_112); +x_134 = lean_ctor_get(x_126, 0); +lean_inc(x_134); +x_135 = lean_ctor_get(x_126, 1); +lean_inc(x_135); +if (lean_is_exclusive(x_126)) { + lean_ctor_release(x_126, 0); + lean_ctor_release(x_126, 1); + x_136 = x_126; +} else { + lean_dec_ref(x_126); + x_136 = lean_box(0); +} +if (lean_is_scalar(x_136)) { + x_137 = lean_alloc_ctor(1, 2, 0); +} else { + x_137 = x_136; +} +lean_ctor_set(x_137, 0, x_134); +lean_ctor_set(x_137, 1, x_135); +return x_137; +} +} +} +else +{ +uint8_t x_138; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_34); +lean_dec(x_23); +lean_dec(x_18); +lean_dec(x_6); +lean_dec(x_2); +x_138 = !lean_is_exclusive(x_43); +if (x_138 == 0) +{ +lean_object* x_139; uint8_t x_140; +x_139 = lean_ctor_get(x_43, 0); +lean_dec(x_139); +x_140 = !lean_is_exclusive(x_44); +if (x_140 == 0) +{ +lean_object* x_141; uint8_t x_142; +x_141 = lean_ctor_get(x_44, 0); +lean_dec(x_141); +x_142 = !lean_is_exclusive(x_45); +if (x_142 == 0) +{ +return x_43; +} +else +{ +lean_object* x_143; lean_object* x_144; lean_object* x_145; +x_143 = lean_ctor_get(x_45, 0); +x_144 = lean_ctor_get(x_45, 1); +lean_inc(x_144); +lean_inc(x_143); +lean_dec(x_45); +x_145 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_145, 0, x_143); +lean_ctor_set(x_145, 1, x_144); +lean_ctor_set(x_44, 0, x_145); +return x_43; +} +} +else +{ +lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_146 = lean_ctor_get(x_44, 1); +lean_inc(x_146); +lean_dec(x_44); +x_147 = lean_ctor_get(x_45, 0); +lean_inc(x_147); +x_148 = lean_ctor_get(x_45, 1); +lean_inc(x_148); +if (lean_is_exclusive(x_45)) { + lean_ctor_release(x_45, 0); + lean_ctor_release(x_45, 1); + x_149 = x_45; +} else { + lean_dec_ref(x_45); + x_149 = lean_box(0); +} +if (lean_is_scalar(x_149)) { + x_150 = lean_alloc_ctor(1, 2, 0); +} else { + x_150 = x_149; +} +lean_ctor_set(x_150, 0, x_147); +lean_ctor_set(x_150, 1, x_148); +x_151 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_151, 0, x_150); +lean_ctor_set(x_151, 1, x_146); +lean_ctor_set(x_43, 0, x_151); +return x_43; +} +} +else +{ +lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_152 = lean_ctor_get(x_43, 1); +lean_inc(x_152); +lean_dec(x_43); +x_153 = lean_ctor_get(x_44, 1); +lean_inc(x_153); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_154 = x_44; +} else { + lean_dec_ref(x_44); + x_154 = lean_box(0); +} +x_155 = lean_ctor_get(x_45, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_45, 1); +lean_inc(x_156); +if (lean_is_exclusive(x_45)) { + lean_ctor_release(x_45, 0); + lean_ctor_release(x_45, 1); + x_157 = x_45; +} else { + lean_dec_ref(x_45); + x_157 = lean_box(0); +} +if (lean_is_scalar(x_157)) { + x_158 = lean_alloc_ctor(1, 2, 0); +} else { + x_158 = x_157; +} +lean_ctor_set(x_158, 0, x_155); +lean_ctor_set(x_158, 1, x_156); +if (lean_is_scalar(x_154)) { + x_159 = lean_alloc_ctor(0, 2, 0); +} else { + x_159 = x_154; +} +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_153); +x_160 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +} +} +else +{ +uint8_t x_161; +lean_dec(x_36); +lean_dec(x_35); +lean_dec(x_34); +lean_dec(x_23); +lean_dec(x_18); +lean_dec(x_6); +lean_dec(x_2); +x_161 = !lean_is_exclusive(x_43); +if (x_161 == 0) +{ +return x_43; +} +else +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_162 = lean_ctor_get(x_43, 0); +x_163 = lean_ctor_get(x_43, 1); +lean_inc(x_163); +lean_inc(x_162); +lean_dec(x_43); +x_164 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_164, 0, x_162); +lean_ctor_set(x_164, 1, x_163); +return x_164; +} +} +} +else +{ +uint8_t x_165; +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_18); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_165 = !lean_is_exclusive(x_27); +if (x_165 == 0) +{ +lean_object* x_166; uint8_t x_167; +x_166 = lean_ctor_get(x_27, 0); +lean_dec(x_166); +x_167 = !lean_is_exclusive(x_28); +if (x_167 == 0) +{ +lean_object* x_168; uint8_t x_169; +x_168 = lean_ctor_get(x_28, 0); +lean_dec(x_168); +x_169 = !lean_is_exclusive(x_29); +if (x_169 == 0) +{ +return x_27; +} +else +{ +lean_object* x_170; lean_object* x_171; lean_object* x_172; +x_170 = lean_ctor_get(x_29, 0); +x_171 = lean_ctor_get(x_29, 1); +lean_inc(x_171); +lean_inc(x_170); +lean_dec(x_29); +x_172 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_172, 0, x_170); +lean_ctor_set(x_172, 1, x_171); +lean_ctor_set(x_28, 0, x_172); +return x_27; +} +} +else +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; +x_173 = lean_ctor_get(x_28, 1); +lean_inc(x_173); +lean_dec(x_28); +x_174 = lean_ctor_get(x_29, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_29, 1); +lean_inc(x_175); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_176 = x_29; +} else { + lean_dec_ref(x_29); + x_176 = lean_box(0); +} +if (lean_is_scalar(x_176)) { + x_177 = lean_alloc_ctor(1, 2, 0); +} else { + x_177 = x_176; +} +lean_ctor_set(x_177, 0, x_174); +lean_ctor_set(x_177, 1, x_175); +x_178 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_173); +lean_ctor_set(x_27, 0, x_178); +return x_27; +} +} +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; +x_179 = lean_ctor_get(x_27, 1); +lean_inc(x_179); +lean_dec(x_27); +x_180 = lean_ctor_get(x_28, 1); +lean_inc(x_180); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_181 = x_28; +} else { + lean_dec_ref(x_28); + x_181 = lean_box(0); +} +x_182 = lean_ctor_get(x_29, 0); +lean_inc(x_182); +x_183 = lean_ctor_get(x_29, 1); +lean_inc(x_183); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_184 = x_29; +} else { + lean_dec_ref(x_29); + x_184 = lean_box(0); +} +if (lean_is_scalar(x_184)) { + x_185 = lean_alloc_ctor(1, 2, 0); +} else { + x_185 = x_184; +} +lean_ctor_set(x_185, 0, x_182); +lean_ctor_set(x_185, 1, x_183); +if (lean_is_scalar(x_181)) { + x_186 = lean_alloc_ctor(0, 2, 0); +} else { + x_186 = x_181; +} +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_180); +x_187 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_179); +return x_187; +} +} +} +else +{ +uint8_t x_188; +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_18); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_188 = !lean_is_exclusive(x_27); +if (x_188 == 0) +{ +return x_27; +} +else +{ +lean_object* x_189; lean_object* x_190; lean_object* x_191; +x_189 = lean_ctor_get(x_27, 0); +x_190 = lean_ctor_get(x_27, 1); +lean_inc(x_190); +lean_inc(x_189); +lean_dec(x_27); +x_191 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_191, 0, x_189); +lean_ctor_set(x_191, 1, x_190); +return x_191; +} +} +} +} +else +{ +uint8_t x_198; +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_198 = !lean_is_exclusive(x_13); +if (x_198 == 0) +{ +lean_object* x_199; uint8_t x_200; +x_199 = lean_ctor_get(x_13, 0); +lean_dec(x_199); +x_200 = !lean_is_exclusive(x_14); +if (x_200 == 0) +{ +lean_object* x_201; uint8_t x_202; +x_201 = lean_ctor_get(x_14, 0); +lean_dec(x_201); +x_202 = !lean_is_exclusive(x_15); +if (x_202 == 0) +{ +return x_13; +} +else +{ +lean_object* x_203; lean_object* x_204; lean_object* x_205; +x_203 = lean_ctor_get(x_15, 0); +x_204 = lean_ctor_get(x_15, 1); +lean_inc(x_204); +lean_inc(x_203); +lean_dec(x_15); +x_205 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_205, 0, x_203); +lean_ctor_set(x_205, 1, x_204); +lean_ctor_set(x_14, 0, x_205); +return x_13; +} +} +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; +x_206 = lean_ctor_get(x_14, 1); +lean_inc(x_206); +lean_dec(x_14); +x_207 = lean_ctor_get(x_15, 0); +lean_inc(x_207); +x_208 = lean_ctor_get(x_15, 1); +lean_inc(x_208); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_209 = x_15; +} else { + lean_dec_ref(x_15); + x_209 = lean_box(0); +} +if (lean_is_scalar(x_209)) { + x_210 = lean_alloc_ctor(1, 2, 0); +} else { + x_210 = x_209; +} +lean_ctor_set(x_210, 0, x_207); +lean_ctor_set(x_210, 1, x_208); +x_211 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_211, 0, x_210); +lean_ctor_set(x_211, 1, x_206); +lean_ctor_set(x_13, 0, x_211); +return x_13; +} +} +else +{ +lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; +x_212 = lean_ctor_get(x_13, 1); +lean_inc(x_212); +lean_dec(x_13); +x_213 = lean_ctor_get(x_14, 1); +lean_inc(x_213); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_214 = x_14; +} else { + lean_dec_ref(x_14); + x_214 = lean_box(0); +} +x_215 = lean_ctor_get(x_15, 0); +lean_inc(x_215); +x_216 = lean_ctor_get(x_15, 1); +lean_inc(x_216); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_217 = x_15; +} else { + lean_dec_ref(x_15); + x_217 = lean_box(0); +} +if (lean_is_scalar(x_217)) { + x_218 = lean_alloc_ctor(1, 2, 0); +} else { + x_218 = x_217; +} +lean_ctor_set(x_218, 0, x_215); +lean_ctor_set(x_218, 1, x_216); +if (lean_is_scalar(x_214)) { + x_219 = lean_alloc_ctor(0, 2, 0); +} else { + x_219 = x_214; +} +lean_ctor_set(x_219, 0, x_218); +lean_ctor_set(x_219, 1, x_213); +x_220 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_220, 0, x_219); +lean_ctor_set(x_220, 1, x_212); +return x_220; +} +} +} +else +{ +uint8_t x_221; +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_221 = !lean_is_exclusive(x_13); +if (x_221 == 0) +{ +return x_13; +} +else +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; +x_222 = lean_ctor_get(x_13, 0); +x_223 = lean_ctor_get(x_13, 1); +lean_inc(x_223); +lean_inc(x_222); +lean_dec(x_13); +x_224 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_224, 0, x_222); +lean_ctor_set(x_224, 1, x_223); +return x_224; +} +} +} +} +static lean_object* _init_l_Lake_Module_recBuildDynlib___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":dynlib", 7); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = 1; +lean_inc(x_8); +x_10 = l_Lean_Name_toString(x_8, x_9); +x_11 = l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1; +x_12 = lean_string_append(x_11, x_10); +lean_dec(x_10); +x_13 = l_Lake_Module_recBuildDynlib___closed__1; +x_14 = lean_string_append(x_12, x_13); +x_15 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +lean_inc(x_1); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_15); +x_17 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, lean_box(0)); +x_18 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib___lambda__6), 9, 2); +lean_closure_set(x_18, 0, x_1); +lean_closure_set(x_18, 1, x_8); +x_19 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Module_recBuildLean___spec__8___rarg), 8, 2); +lean_closure_set(x_19, 0, x_17); +lean_closure_set(x_19, 1, x_18); +x_20 = l_Lake_withRegisterJob___rarg(x_14, x_19, x_2, x_3, x_4, x_5, x_6, x_7); +return x_20; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__1(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +size_t x_4; size_t x_5; lean_object* x_6; +x_4 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__2(x_4, x_5, x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +size_t x_4; size_t x_5; lean_object* x_6; +x_4 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3(x_4, x_5, x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +size_t x_4; size_t x_5; lean_object* x_6; +x_4 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4(x_4, x_5, x_3); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_Module_recBuildDynlib___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +lean_dec(x_2); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +_start: +{ +size_t x_15; lean_object* x_16; +x_15 = lean_unbox_usize(x_8); +lean_dec(x_8); +x_16 = l_Lake_Module_recBuildDynlib___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_15, x_9, x_10, x_11, x_12, x_13, x_14); +lean_dec(x_2); +return x_16; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +size_t x_13; lean_object* x_14; +x_13 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_14 = l_Lake_Module_recBuildDynlib___lambda__3(x_1, x_13, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12); +return x_14; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; lean_object* x_13; +x_12 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_13 = l_Lake_Module_recBuildDynlib___lambda__4(x_1, x_12, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_recBuildDynlib___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; lean_object* x_12; +x_11 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_12 = l_Lake_Module_recBuildDynlib___lambda__5(x_1, x_2, x_11, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Module_dynlibFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_Module_dynlibFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Module_dynlibFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_dynlibFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Module_dynlibFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Module_dynlibFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Module_recBuildDynlib), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Module_dynlibFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Module_dynlibFacetConfig___closed__3; +x_2 = l_Lake_Module_dynlibFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Module_dynlibFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Module_dynlibFacetConfig___closed__4; +return x_1; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = lean_box(0); +x_2 = l_Lake_Module_importsFacetConfig___closed__2; +x_3 = l_Lake_Module_importsFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__1; +x_2 = l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2; +x_3 = l_Lake_Module_transImportsFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__2; +x_2 = l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2; +x_3 = l_Lake_Module_precompileImportsFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__3; +x_2 = l_Lake_Module_depsFacetConfig___closed__4; +x_3 = l_Lake_Module_depsFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__4; +x_2 = l_Lake_Module_leanArtsFacetConfig___closed__4; +x_3 = l_Lake_Module_leanArtsFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__5; +x_2 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__2; +x_3 = l_Lake_Module_oleanFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__6; +x_2 = l_Lake_Module_ileanFacetConfig___closed__1; +x_3 = l_Lake_Module_ileanFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__7; +x_2 = l_Lake_Module_cFacetConfig___closed__1; +x_3 = l_Lake_Module_cFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__8; +x_2 = l_Lake_Module_bcFacetConfig___closed__1; +x_3 = l_Lake_Module_bcFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__9; +x_2 = l_Lake_Module_coFacetConfig___closed__1; +x_3 = l_Lake_Module_coFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__10; +x_2 = l_Lake_Module_coExportFacetConfig___closed__3; +x_3 = l_Lake_Module_coExportFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__11; +x_2 = l_Lake_Module_coNoExportFacetConfig___closed__2; +x_3 = l_Lake_Module_coNoExportFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__12; +x_2 = l_Lake_Module_bcoFacetConfig___closed__1; +x_3 = l_Lake_Module_bcoFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__13; +x_2 = l_Lake_Module_oFacetConfig___closed__1; +x_3 = l_Lake_Module_oFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__15() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__14; +x_2 = l_Lake_Module_oExportFacetConfig___closed__1; +x_3 = l_Lake_Module_oExportFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__16() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__15; +x_2 = l_Lake_Module_oNoExportFacetConfig___closed__1; +x_3 = l_Lake_Module_oNoExportFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs___closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initModuleFacetConfigs___closed__16; +x_2 = l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__2; +x_3 = l_Lake_Module_dynlibFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addModuleFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initModuleFacetConfigs() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_initModuleFacetConfigs___closed__17; +return x_1; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_OrdHashSet(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_List(uint8_t builtin, lean_object*); +lean_object* initialize_Lean_Elab_ParseImportsFast(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Common(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Module(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_OrdHashSet(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_List(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lean_Elab_ParseImportsFast(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Common(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_recBuildExternDynlibs___spec__3___closed__1); +l_Lake_recBuildExternDynlibs___closed__1 = _init_l_Lake_recBuildExternDynlibs___closed__1(); +lean_mark_persistent(l_Lake_recBuildExternDynlibs___closed__1); +l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__1 = _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__1(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__1); +l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__2 = _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__2(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_Module_recParseImports___spec__2___closed__2); +l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__1 = _init_l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__1(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__1); +l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__2 = _init_l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__2(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__2); +l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__3 = _init_l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__3(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_Module_recParseImports___spec__12___closed__3); +l_Lake_Module_recParseImports___closed__1 = _init_l_Lake_Module_recParseImports___closed__1(); +lean_mark_persistent(l_Lake_Module_recParseImports___closed__1); +l_Lake_Module_importsFacetConfig___closed__1 = _init_l_Lake_Module_importsFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_importsFacetConfig___closed__1); +l_Lake_Module_importsFacetConfig___closed__2 = _init_l_Lake_Module_importsFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_importsFacetConfig___closed__2); +l_Lake_Module_importsFacetConfig___closed__3 = _init_l_Lake_Module_importsFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_importsFacetConfig___closed__3); +l_Lake_Module_importsFacetConfig___closed__4 = _init_l_Lake_Module_importsFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Module_importsFacetConfig___closed__4); +l_Lake_Module_importsFacetConfig = _init_l_Lake_Module_importsFacetConfig(); +lean_mark_persistent(l_Lake_Module_importsFacetConfig); +l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__1); +l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2 = _init_l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__2); +l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3 = _init_l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_collectImportsAux___spec__3___closed__3); +l_Lake_collectImportsAux___closed__1 = _init_l_Lake_collectImportsAux___closed__1(); +lean_mark_persistent(l_Lake_collectImportsAux___closed__1); +l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__1); +l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2 = _init_l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_Module_recComputeTransImports___spec__1___closed__2); +l_Lake_Module_transImportsFacetConfig___closed__1 = _init_l_Lake_Module_transImportsFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_transImportsFacetConfig___closed__1); +l_Lake_Module_transImportsFacetConfig___closed__2 = _init_l_Lake_Module_transImportsFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_transImportsFacetConfig___closed__2); +l_Lake_Module_transImportsFacetConfig = _init_l_Lake_Module_transImportsFacetConfig(); +lean_mark_persistent(l_Lake_Module_transImportsFacetConfig); +l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__1); +l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2 = _init_l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_computePrecompileImportsAux___spec__1___closed__2); +l_Lake_Module_precompileImportsFacetConfig___closed__1 = _init_l_Lake_Module_precompileImportsFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_precompileImportsFacetConfig___closed__1); +l_Lake_Module_precompileImportsFacetConfig___closed__2 = _init_l_Lake_Module_precompileImportsFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_precompileImportsFacetConfig___closed__2); +l_Lake_Module_precompileImportsFacetConfig = _init_l_Lake_Module_precompileImportsFacetConfig(); +lean_mark_persistent(l_Lake_Module_precompileImportsFacetConfig); +l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1 = _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__1); +l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__2 = _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__2(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___lambda__1___closed__2); +l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___closed__1 = _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___closed__1(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__1___closed__1); +l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__1 = _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__1(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__1); +l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__2 = _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__2(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDeps___spec__2___closed__2); +l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__1 = _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__1(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__1); +l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__2 = _init_l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__2(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_Module_recBuildDeps___spec__3___closed__2); +l_Lake_Module_recBuildDeps___lambda__1___closed__1 = _init_l_Lake_Module_recBuildDeps___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildDeps___lambda__1___closed__1); +l_Lake_Module_recBuildDeps___lambda__1___closed__2 = _init_l_Lake_Module_recBuildDeps___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_Module_recBuildDeps___lambda__1___closed__2); +l_Lake_Module_recBuildDeps___lambda__1___closed__3___boxed__const__1 = _init_l_Lake_Module_recBuildDeps___lambda__1___closed__3___boxed__const__1(); +lean_mark_persistent(l_Lake_Module_recBuildDeps___lambda__1___closed__3___boxed__const__1); +l_Lake_Module_recBuildDeps___lambda__1___closed__3 = _init_l_Lake_Module_recBuildDeps___lambda__1___closed__3(); +lean_mark_persistent(l_Lake_Module_recBuildDeps___lambda__1___closed__3); +l_Lake_Module_recBuildDeps___closed__1 = _init_l_Lake_Module_recBuildDeps___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildDeps___closed__1); +l_Lake_Module_recBuildDeps___closed__2 = _init_l_Lake_Module_recBuildDeps___closed__2(); +lean_mark_persistent(l_Lake_Module_recBuildDeps___closed__2); +l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__1 = _init_l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__1(); +lean_mark_persistent(l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__1); +l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2 = _init_l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2(); +lean_mark_persistent(l_Functor_discard___at_Lake_Module_depsFacetConfig___spec__1___closed__2); +l_Lake_Module_depsFacetConfig___closed__1 = _init_l_Lake_Module_depsFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_depsFacetConfig___closed__1); +l_Lake_Module_depsFacetConfig___closed__2 = _init_l_Lake_Module_depsFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_depsFacetConfig___closed__2); +l_Lake_Module_depsFacetConfig___closed__3 = _init_l_Lake_Module_depsFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_depsFacetConfig___closed__3); +l_Lake_Module_depsFacetConfig___closed__4 = _init_l_Lake_Module_depsFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Module_depsFacetConfig___closed__4); +l_Lake_Module_depsFacetConfig___closed__5 = _init_l_Lake_Module_depsFacetConfig___closed__5(); +lean_mark_persistent(l_Lake_Module_depsFacetConfig___closed__5); +l_Lake_Module_depsFacetConfig___closed__6 = _init_l_Lake_Module_depsFacetConfig___closed__6(); +lean_mark_persistent(l_Lake_Module_depsFacetConfig___closed__6); +l_Lake_Module_depsFacetConfig = _init_l_Lake_Module_depsFacetConfig(); +lean_mark_persistent(l_Lake_Module_depsFacetConfig); +l_Lake_Module_clearOutputHashes___closed__1 = _init_l_Lake_Module_clearOutputHashes___closed__1(); +lean_mark_persistent(l_Lake_Module_clearOutputHashes___closed__1); +l_Lake_Module_clearOutputHashes___closed__2 = _init_l_Lake_Module_clearOutputHashes___closed__2(); +lean_mark_persistent(l_Lake_Module_clearOutputHashes___closed__2); +l_Lake_Module_clearOutputHashes___closed__3 = _init_l_Lake_Module_clearOutputHashes___closed__3(); +l_Lake_Module_clearOutputHashes___closed__4 = _init_l_Lake_Module_clearOutputHashes___closed__4(); +lean_mark_persistent(l_Lake_Module_clearOutputHashes___closed__4); +l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___closed__1 = _init_l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___lambda__3___closed__1(); +l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1 = _init_l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1(); +lean_mark_persistent(l_Lake_buildUnlessUpToDate_x3f___at_Lake_Module_recBuildLean___spec__1___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__1 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__1(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__2 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__2(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__3 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__3(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__3); +l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__4 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__4(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__4); +l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Module_recBuildLean___spec__4___closed__5); +l_Lake_Module_recBuildLean___lambda__3___closed__1 = _init_l_Lake_Module_recBuildLean___lambda__3___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLean___lambda__3___closed__1); +l_Lake_Module_recBuildLean___lambda__5___closed__1 = _init_l_Lake_Module_recBuildLean___lambda__5___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLean___lambda__5___closed__1); +l_Lake_Module_leanArtsFacetConfig___closed__1 = _init_l_Lake_Module_leanArtsFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_leanArtsFacetConfig___closed__1); +l_Lake_Module_leanArtsFacetConfig___closed__2 = _init_l_Lake_Module_leanArtsFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_leanArtsFacetConfig___closed__2); +l_Lake_Module_leanArtsFacetConfig___closed__3 = _init_l_Lake_Module_leanArtsFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_leanArtsFacetConfig___closed__3); +l_Lake_Module_leanArtsFacetConfig___closed__4 = _init_l_Lake_Module_leanArtsFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Module_leanArtsFacetConfig___closed__4); +l_Lake_Module_leanArtsFacetConfig___closed__5 = _init_l_Lake_Module_leanArtsFacetConfig___closed__5(); +lean_mark_persistent(l_Lake_Module_leanArtsFacetConfig___closed__5); +l_Lake_Module_leanArtsFacetConfig___closed__6 = _init_l_Lake_Module_leanArtsFacetConfig___closed__6(); +lean_mark_persistent(l_Lake_Module_leanArtsFacetConfig___closed__6); +l_Lake_Module_leanArtsFacetConfig = _init_l_Lake_Module_leanArtsFacetConfig(); +lean_mark_persistent(l_Lake_Module_leanArtsFacetConfig); +l_Lake_Module_oleanFacetConfig___closed__1 = _init_l_Lake_Module_oleanFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_oleanFacetConfig___closed__1); +l_Lake_Module_oleanFacetConfig___closed__2 = _init_l_Lake_Module_oleanFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_oleanFacetConfig___closed__2); +l_Lake_Module_oleanFacetConfig___closed__3 = _init_l_Lake_Module_oleanFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_oleanFacetConfig___closed__3); +l_Lake_Module_oleanFacetConfig___closed__4 = _init_l_Lake_Module_oleanFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Module_oleanFacetConfig___closed__4); +l_Lake_Module_oleanFacetConfig = _init_l_Lake_Module_oleanFacetConfig(); +lean_mark_persistent(l_Lake_Module_oleanFacetConfig); +l_Lake_Module_ileanFacetConfig___closed__1 = _init_l_Lake_Module_ileanFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_ileanFacetConfig___closed__1); +l_Lake_Module_ileanFacetConfig___closed__2 = _init_l_Lake_Module_ileanFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_ileanFacetConfig___closed__2); +l_Lake_Module_ileanFacetConfig___closed__3 = _init_l_Lake_Module_ileanFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_ileanFacetConfig___closed__3); +l_Lake_Module_ileanFacetConfig = _init_l_Lake_Module_ileanFacetConfig(); +lean_mark_persistent(l_Lake_Module_ileanFacetConfig); +l_Lake_Module_cFacetConfig___closed__1 = _init_l_Lake_Module_cFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_cFacetConfig___closed__1); +l_Lake_Module_cFacetConfig___closed__2 = _init_l_Lake_Module_cFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_cFacetConfig___closed__2); +l_Lake_Module_cFacetConfig___closed__3 = _init_l_Lake_Module_cFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_cFacetConfig___closed__3); +l_Lake_Module_cFacetConfig = _init_l_Lake_Module_cFacetConfig(); +lean_mark_persistent(l_Lake_Module_cFacetConfig); +l_Lake_Module_bcFacetConfig___closed__1 = _init_l_Lake_Module_bcFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_bcFacetConfig___closed__1); +l_Lake_Module_bcFacetConfig___closed__2 = _init_l_Lake_Module_bcFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_bcFacetConfig___closed__2); +l_Lake_Module_bcFacetConfig___closed__3 = _init_l_Lake_Module_bcFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_bcFacetConfig___closed__3); +l_Lake_Module_bcFacetConfig = _init_l_Lake_Module_bcFacetConfig(); +lean_mark_persistent(l_Lake_Module_bcFacetConfig); +l_Lake_Module_recBuildLeanCToOExport___lambda__5___closed__1 = _init_l_Lake_Module_recBuildLeanCToOExport___lambda__5___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___lambda__5___closed__1); +l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__1 = _init_l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__1); +l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2 = _init_l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___lambda__7___closed__2); +l_Lake_Module_recBuildLeanCToOExport___closed__1 = _init_l_Lake_Module_recBuildLeanCToOExport___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___closed__1); +l_Lake_Module_recBuildLeanCToOExport___closed__2 = _init_l_Lake_Module_recBuildLeanCToOExport___closed__2(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___closed__2); +l_Lake_Module_recBuildLeanCToOExport___closed__3 = _init_l_Lake_Module_recBuildLeanCToOExport___closed__3(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___closed__3); +l_Lake_Module_recBuildLeanCToOExport___closed__4 = _init_l_Lake_Module_recBuildLeanCToOExport___closed__4(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___closed__4); +l_Lake_Module_recBuildLeanCToOExport___closed__5 = _init_l_Lake_Module_recBuildLeanCToOExport___closed__5(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToOExport___closed__5); +l_Lake_Module_coExportFacetConfig___closed__1 = _init_l_Lake_Module_coExportFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_coExportFacetConfig___closed__1); +l_Lake_Module_coExportFacetConfig___closed__2 = _init_l_Lake_Module_coExportFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_coExportFacetConfig___closed__2); +l_Lake_Module_coExportFacetConfig___closed__3 = _init_l_Lake_Module_coExportFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_coExportFacetConfig___closed__3); +l_Lake_Module_coExportFacetConfig___closed__4 = _init_l_Lake_Module_coExportFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Module_coExportFacetConfig___closed__4); +l_Lake_Module_coExportFacetConfig___closed__5 = _init_l_Lake_Module_coExportFacetConfig___closed__5(); +lean_mark_persistent(l_Lake_Module_coExportFacetConfig___closed__5); +l_Lake_Module_coExportFacetConfig = _init_l_Lake_Module_coExportFacetConfig(); +lean_mark_persistent(l_Lake_Module_coExportFacetConfig); +l_Lake_Module_recBuildLeanCToONoExport___lambda__1___closed__1 = _init_l_Lake_Module_recBuildLeanCToONoExport___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToONoExport___lambda__1___closed__1); +l_Lake_Module_recBuildLeanCToONoExport___closed__1 = _init_l_Lake_Module_recBuildLeanCToONoExport___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLeanCToONoExport___closed__1); +l_Lake_Module_coNoExportFacetConfig___closed__1 = _init_l_Lake_Module_coNoExportFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_coNoExportFacetConfig___closed__1); +l_Lake_Module_coNoExportFacetConfig___closed__2 = _init_l_Lake_Module_coNoExportFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_coNoExportFacetConfig___closed__2); +l_Lake_Module_coNoExportFacetConfig___closed__3 = _init_l_Lake_Module_coNoExportFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_coNoExportFacetConfig___closed__3); +l_Lake_Module_coNoExportFacetConfig___closed__4 = _init_l_Lake_Module_coNoExportFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Module_coNoExportFacetConfig___closed__4); +l_Lake_Module_coNoExportFacetConfig = _init_l_Lake_Module_coNoExportFacetConfig(); +lean_mark_persistent(l_Lake_Module_coNoExportFacetConfig); +l_Lake_Module_coFacetConfig___closed__1 = _init_l_Lake_Module_coFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_coFacetConfig___closed__1); +l_Lake_Module_coFacetConfig___closed__2 = _init_l_Lake_Module_coFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_coFacetConfig___closed__2); +l_Lake_Module_coFacetConfig___closed__3 = _init_l_Lake_Module_coFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_coFacetConfig___closed__3); +l_Lake_Module_coFacetConfig = _init_l_Lake_Module_coFacetConfig(); +lean_mark_persistent(l_Lake_Module_coFacetConfig); +l_Lake_Module_recBuildLeanBcToO___lambda__1___closed__1 = _init_l_Lake_Module_recBuildLeanBcToO___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLeanBcToO___lambda__1___closed__1); +l_Lake_Module_recBuildLeanBcToO___closed__1 = _init_l_Lake_Module_recBuildLeanBcToO___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildLeanBcToO___closed__1); +l_Lake_Module_bcoFacetConfig___closed__1 = _init_l_Lake_Module_bcoFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_bcoFacetConfig___closed__1); +l_Lake_Module_bcoFacetConfig___closed__2 = _init_l_Lake_Module_bcoFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_bcoFacetConfig___closed__2); +l_Lake_Module_bcoFacetConfig___closed__3 = _init_l_Lake_Module_bcoFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_bcoFacetConfig___closed__3); +l_Lake_Module_bcoFacetConfig = _init_l_Lake_Module_bcoFacetConfig(); +lean_mark_persistent(l_Lake_Module_bcoFacetConfig); +l_Lake_Module_oExportFacetConfig___closed__1 = _init_l_Lake_Module_oExportFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_oExportFacetConfig___closed__1); +l_Lake_Module_oExportFacetConfig___closed__2 = _init_l_Lake_Module_oExportFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_oExportFacetConfig___closed__2); +l_Lake_Module_oExportFacetConfig___closed__3 = _init_l_Lake_Module_oExportFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_oExportFacetConfig___closed__3); +l_Lake_Module_oExportFacetConfig = _init_l_Lake_Module_oExportFacetConfig(); +lean_mark_persistent(l_Lake_Module_oExportFacetConfig); +l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__1 = _init_l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__1(); +lean_mark_persistent(l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__1); +l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__2 = _init_l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__2(); +lean_mark_persistent(l_Lake_Module_oNoExportFacetConfig___elambda__1___closed__2); +l_Lake_Module_oNoExportFacetConfig___closed__1 = _init_l_Lake_Module_oNoExportFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_oNoExportFacetConfig___closed__1); +l_Lake_Module_oNoExportFacetConfig___closed__2 = _init_l_Lake_Module_oNoExportFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_oNoExportFacetConfig___closed__2); +l_Lake_Module_oNoExportFacetConfig___closed__3 = _init_l_Lake_Module_oNoExportFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_oNoExportFacetConfig___closed__3); +l_Lake_Module_oNoExportFacetConfig = _init_l_Lake_Module_oNoExportFacetConfig(); +lean_mark_persistent(l_Lake_Module_oNoExportFacetConfig); +l_Lake_Module_oFacetConfig___closed__1 = _init_l_Lake_Module_oFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_oFacetConfig___closed__1); +l_Lake_Module_oFacetConfig___closed__2 = _init_l_Lake_Module_oFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_oFacetConfig___closed__2); +l_Lake_Module_oFacetConfig___closed__3 = _init_l_Lake_Module_oFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_oFacetConfig___closed__3); +l_Lake_Module_oFacetConfig = _init_l_Lake_Module_oFacetConfig(); +lean_mark_persistent(l_Lake_Module_oFacetConfig); +l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___closed__1 = _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___closed__1(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__3___closed__1); +l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___closed__1 = _init_l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___closed__1(); +lean_mark_persistent(l_Array_mapMUnsafe_map___at_Lake_Module_recBuildDynlib___spec__4___closed__1); +l_Lake_Module_recBuildDynlib___lambda__2___closed__1 = _init_l_Lake_Module_recBuildDynlib___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildDynlib___lambda__2___closed__1); +l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1 = _init_l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1(); +lean_mark_persistent(l_Lake_Module_recBuildDynlib___lambda__6___boxed__const__1); +l_Lake_Module_recBuildDynlib___closed__1 = _init_l_Lake_Module_recBuildDynlib___closed__1(); +lean_mark_persistent(l_Lake_Module_recBuildDynlib___closed__1); +l_Lake_Module_dynlibFacetConfig___closed__1 = _init_l_Lake_Module_dynlibFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Module_dynlibFacetConfig___closed__1); +l_Lake_Module_dynlibFacetConfig___closed__2 = _init_l_Lake_Module_dynlibFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Module_dynlibFacetConfig___closed__2); +l_Lake_Module_dynlibFacetConfig___closed__3 = _init_l_Lake_Module_dynlibFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Module_dynlibFacetConfig___closed__3); +l_Lake_Module_dynlibFacetConfig___closed__4 = _init_l_Lake_Module_dynlibFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Module_dynlibFacetConfig___closed__4); +l_Lake_Module_dynlibFacetConfig = _init_l_Lake_Module_dynlibFacetConfig(); +lean_mark_persistent(l_Lake_Module_dynlibFacetConfig); +l_Lake_initModuleFacetConfigs___closed__1 = _init_l_Lake_initModuleFacetConfigs___closed__1(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__1); +l_Lake_initModuleFacetConfigs___closed__2 = _init_l_Lake_initModuleFacetConfigs___closed__2(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__2); +l_Lake_initModuleFacetConfigs___closed__3 = _init_l_Lake_initModuleFacetConfigs___closed__3(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__3); +l_Lake_initModuleFacetConfigs___closed__4 = _init_l_Lake_initModuleFacetConfigs___closed__4(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__4); +l_Lake_initModuleFacetConfigs___closed__5 = _init_l_Lake_initModuleFacetConfigs___closed__5(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__5); +l_Lake_initModuleFacetConfigs___closed__6 = _init_l_Lake_initModuleFacetConfigs___closed__6(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__6); +l_Lake_initModuleFacetConfigs___closed__7 = _init_l_Lake_initModuleFacetConfigs___closed__7(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__7); +l_Lake_initModuleFacetConfigs___closed__8 = _init_l_Lake_initModuleFacetConfigs___closed__8(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__8); +l_Lake_initModuleFacetConfigs___closed__9 = _init_l_Lake_initModuleFacetConfigs___closed__9(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__9); +l_Lake_initModuleFacetConfigs___closed__10 = _init_l_Lake_initModuleFacetConfigs___closed__10(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__10); +l_Lake_initModuleFacetConfigs___closed__11 = _init_l_Lake_initModuleFacetConfigs___closed__11(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__11); +l_Lake_initModuleFacetConfigs___closed__12 = _init_l_Lake_initModuleFacetConfigs___closed__12(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__12); +l_Lake_initModuleFacetConfigs___closed__13 = _init_l_Lake_initModuleFacetConfigs___closed__13(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__13); +l_Lake_initModuleFacetConfigs___closed__14 = _init_l_Lake_initModuleFacetConfigs___closed__14(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__14); +l_Lake_initModuleFacetConfigs___closed__15 = _init_l_Lake_initModuleFacetConfigs___closed__15(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__15); +l_Lake_initModuleFacetConfigs___closed__16 = _init_l_Lake_initModuleFacetConfigs___closed__16(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__16); +l_Lake_initModuleFacetConfigs___closed__17 = _init_l_Lake_initModuleFacetConfigs___closed__17(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs___closed__17); +l_Lake_initModuleFacetConfigs = _init_l_Lake_initModuleFacetConfigs(); +lean_mark_persistent(l_Lake_initModuleFacetConfigs); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Package.c b/stage0/stdlib/Lake/Build/Package.c new file mode 100644 index 0000000000..17d45cdb2d --- /dev/null +++ b/stage0/stdlib/Lake/Build/Package.c @@ -0,0 +1,30527 @@ +// Lean compiler output +// Module: Lake.Build.Package +// Imports: Init Lake.Util.Git Lake.Util.Sugar Lake.Build.Common Lake.Build.Targets +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__1; +static lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2___closed__1; +lean_object* l_Lake_GitRepo_getFilteredRemoteUrl_x3f(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Package_fetchTargetJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___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_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +uint8_t lean_uint32_to_uint8(uint32_t); +static lean_object* l_Lake_Package_depsFacetConfig___closed__2; +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__9; +LEAN_EXPORT lean_object* l_Lake_initPackageFacetConfigs; +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__8(lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__16; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_System_FilePath_join(lean_object*, lean_object*); +static lean_object* l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__1; +lean_object* l_Lake_BuildJob_add___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__5(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__10(lean_object*); +static lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__5; +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__1; +uint64_t lean_uint64_mix_hash(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_get_set_stdout(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*); +size_t lean_hashset_mk_idx(lean_object*, uint64_t); +static uint8_t l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___closed__1; +lean_object* lean_io_as_task(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___lambda__1(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_fetchOptRelease___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__3; +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_depsFacetConfig___closed__1; +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_Package_recComputeDeps___spec__2(lean_object*, lean_object*); +static lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__4; +LEAN_EXPORT uint8_t l_List_elem___at_Lake_Package_recComputeDeps___spec__3(lean_object*, lean_object*); +lean_object* lean_mk_array(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_recBuildExtraDepTargets___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_usize_dec_eq(size_t, size_t); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__14; +lean_object* l_Lake_download(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_fget(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_fetchOptRelease___spec__2(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__2; +extern lean_object* l_Lake_instOrdJobAction; +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__4; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint64_t lean_string_hash(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__9(lean_object*); +static lean_object* l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__2; +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__10; +static lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__2; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_Package_recComputeDeps___spec__2___boxed(lean_object*, lean_object*); +extern lean_object* l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_System_FilePath_pathExists(lean_object*, lean_object*); +lean_object* l_Lake_readTraceFile_x3f(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__2___closed__1; +uint8_t lean_string_validate_utf8(lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__17; +static lean_object* l_Lake_initPackageFacetConfigs___closed__3; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__8; +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_fetchOptRelease___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +size_t lean_usize_of_nat(lean_object*); +uint8_t l_String_isEmpty(lean_object*); +lean_object* lean_task_pure(lean_object*); +uint8_t l_instDecidableNot___rarg(uint8_t); +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__2; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__9; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_captureProc_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__12(lean_object*); +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Package_recComputeDeps___spec__9(lean_object*, lean_object*, lean_object*); +lean_object* lean_nat_to_int(lean_object*); +extern lean_object* l_ByteArray_empty; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__5; +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_recBuildExtraDepTargets___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__2; +static lean_object* l_Lake_Package_optReleaseFacetConfig___closed__3; +lean_object* l_Lake_BuildInfo_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_withRegisterJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_optReleaseFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_fetchOptRelease___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync(lean_object*); +lean_object* lean_st_ref_get(lean_object*, lean_object*); +static lean_object* l_Lake_Package_optReleaseFacetConfig___closed__1; +static lean_object* l_Lake_initPackageFacetConfigs___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_releaseFacetConfig___closed__3; +lean_object* lean_st_mk_ref(lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__7; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__4; +LEAN_EXPORT lean_object* l_Lake_Package_optReleaseFacetConfig; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__6; +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync(lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__22; +lean_object* l_Lake_JobState_merge(lean_object*, lean_object*); +lean_object* l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_releaseFacetConfig___closed__1; +lean_object* lean_io_map_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +lean_object* l_panic___at_String_fromUTF8_x21___spec__1(lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__12; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__11; +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Task_Priority_default; +static lean_object* l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__2; +uint8_t lean_name_eq(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +lean_object* l_IO_FS_Stream_ofBuffer(lean_object*); +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Package_recComputeDeps___spec__7___at_Lake_Package_recComputeDeps___spec__8(lean_object*, lean_object*); +lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildJob_mix___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__11(lean_object*); +extern lean_object* l_Lake_BuildTrace_nil; +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_get_set_stderr(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync___rarg___lambda__1(lean_object*, lean_object*); +lean_object* l_Lake_EResult_map___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__2(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__1; +extern lean_object* l_Lake_defaultLakeDir; +lean_object* lean_string_from_utf8(lean_object*); +static lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__2; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__12___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_untar(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); +extern lean_object* l_Lake_Git_defaultRemote; +LEAN_EXPORT lean_object* l_Lake_Package_optReleaseFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__6(lean_object*); +lean_object* l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___closed__2; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_recComputeDeps___closed__1; +lean_object* l_Array_extract___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__9___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Array_mapMUnsafe_map___at_Lake_Package_deps___spec__1(size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_depsFacetConfig; +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__4(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__11___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10(lean_object*, size_t, size_t, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__21; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__3(lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +static lean_object* l_Lake_Package_extraDepFacetConfig___closed__2; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__7; +static lean_object* l_Lake_Package_extraDepFacetConfig___closed__3; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_releaseFacetConfig___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_extraDepFacetConfig___closed__4; +uint64_t l_Lean_Name_hash___override(lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__3; +lean_object* lean_io_exit(uint8_t, lean_object*); +uint8_t l_instDecidableRelLe___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_extraDepFacetConfig; +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_instHashablePackage___boxed(lean_object*); +static lean_object* l_Lake_Package_releaseFacetConfig___closed__4; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_recBuildExtraDepTargets___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_task_map(lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Package_recComputeDeps___spec__7(lean_object*, lean_object*, lean_object*); +lean_object* lean_nat_mul(lean_object*, lean_object*); +lean_object* lean_io_bind_task(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); +static lean_object* l_Lake_initPackageFacetConfigs___closed__4; +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___lambda__1(lean_object*); +lean_object* lean_get_set_stdin(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__5; +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_List_elem___at_Lake_Package_recComputeDeps___spec__3___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__6; +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__1; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__3; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__2; +static lean_object* l_Lake_Package_recBuildExtraDepTargets___closed__4; +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1; +size_t lean_usize_add(size_t, size_t); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_Package_recComputeDeps___spec__4(lean_object*, lean_object*); +lean_object* lean_array_uget(lean_object*, size_t); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__18; +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__2; +lean_object* lean_io_error_to_string(lean_object*); +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Package_recBuildExtraDepTargets___spec__7(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_RBNode_insert___at_Lake_Workspace_addPackageFacetConfig___spec__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_optReleaseFacetConfig___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__20; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__2(lean_object*); +lean_object* l_Lake_instBEqPackage___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_writeTraceFile(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_string_append(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__5(lean_object*, lean_object*, lean_object*); +extern uint32_t l_Lake_noBuildCode; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_Package_recComputeDeps___spec__6(lean_object*, lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__19; +static lean_object* l_Lake_Package_extraDepFacetConfig___closed__1; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__3; +static lean_object* l_Lake_initPackageFacetConfigs___closed__1; +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_Package_recComputeDeps___spec__5(lean_object*, lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +static lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___closed__1; +uint8_t lean_usize_dec_lt(size_t, size_t); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__15; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_fetchOptRelease___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_nat_add(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__8; +LEAN_EXPORT lean_object* l_Lake_Package_recComputeDeps(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Package_recBuildExtraDepTargets___spec__7___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__1; +lean_object* lean_array_uset(lean_object*, size_t, lean_object*); +static lean_object* l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__1(lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_optReleaseFacetConfig___closed__4; +lean_object* l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__1; +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Package_recComputeDeps___spec__9___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchOptRelease___lambda__3___closed__23; +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__10___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_List_elem___at_Lake_Package_recComputeDeps___spec__3(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = 0; +return x_3; +} +else +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_ctor_get(x_4, 2); +x_7 = lean_ctor_get(x_6, 2); +x_8 = lean_ctor_get(x_1, 2); +x_9 = lean_ctor_get(x_8, 2); +x_10 = lean_name_eq(x_7, x_9); +if (x_10 == 0) +{ +x_2 = x_5; +goto _start; +} +else +{ +uint8_t x_12; +x_12 = 1; +return x_12; +} +} +} +} +LEAN_EXPORT uint8_t l_Lean_HashSetImp_contains___at_Lake_Package_recComputeDeps___spec__2(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint64_t x_7; size_t x_8; lean_object* x_9; uint8_t x_10; +x_3 = lean_ctor_get(x_1, 1); +x_4 = lean_array_get_size(x_3); +x_5 = lean_ctor_get(x_2, 2); +x_6 = lean_ctor_get(x_5, 2); +x_7 = l_Lean_Name_hash___override(x_6); +x_8 = lean_hashset_mk_idx(x_4, x_7); +x_9 = lean_array_uget(x_3, x_8); +x_10 = l_List_elem___at_Lake_Package_recComputeDeps___spec__3(x_2, x_9); +lean_dec(x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Package_recComputeDeps___spec__7(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_3, 1); +x_7 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_5); +x_8 = lean_apply_1(x_1, x_5); +x_9 = lean_unbox_uint64(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_7, x_9); +x_11 = lean_array_uget(x_2, x_10); +lean_ctor_set(x_3, 1, x_11); +x_12 = lean_array_uset(x_2, x_10, x_3); +x_2 = x_12; +x_3 = x_6; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint64_t x_18; size_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_14 = lean_ctor_get(x_3, 0); +x_15 = lean_ctor_get(x_3, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_3); +x_16 = lean_array_get_size(x_2); +lean_inc(x_1); +lean_inc(x_14); +x_17 = lean_apply_1(x_1, x_14); +x_18 = lean_unbox_uint64(x_17); +lean_dec(x_17); +x_19 = lean_hashset_mk_idx(x_16, x_18); +x_20 = lean_array_uget(x_2, x_19); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_14); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_array_uset(x_2, x_19, x_21); +x_2 = x_22; +x_3 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_List_foldl___at_Lake_Package_recComputeDeps___spec__7___at_Lake_Package_recComputeDeps___spec__8(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +return x_1; +} +else +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; lean_object* x_12; +x_4 = lean_ctor_get(x_2, 0); +x_5 = lean_ctor_get(x_2, 1); +x_6 = lean_array_get_size(x_1); +x_7 = lean_ctor_get(x_4, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 2); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lean_Name_hash___override(x_8); +lean_dec(x_8); +x_10 = lean_hashset_mk_idx(x_6, x_9); +x_11 = lean_array_uget(x_1, x_10); +lean_ctor_set(x_2, 1, x_11); +x_12 = lean_array_uset(x_1, x_10, x_2); +x_1 = x_12; +x_2 = x_5; +goto _start; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint64_t x_19; size_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_14 = lean_ctor_get(x_2, 0); +x_15 = lean_ctor_get(x_2, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_2); +x_16 = lean_array_get_size(x_1); +x_17 = lean_ctor_get(x_14, 2); +lean_inc(x_17); +x_18 = lean_ctor_get(x_17, 2); +lean_inc(x_18); +lean_dec(x_17); +x_19 = l_Lean_Name_hash___override(x_18); +lean_dec(x_18); +x_20 = lean_hashset_mk_idx(x_16, x_19); +x_21 = lean_array_uget(x_1, x_20); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_14); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_array_uset(x_1, x_20, x_22); +x_1 = x_23; +x_2 = x_15; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_moveEntries___at_Lake_Package_recComputeDeps___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_array_get_size(x_2); +x_5 = lean_nat_dec_lt(x_1, x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_6 = lean_array_fget(x_2, x_1); +x_7 = lean_box(0); +x_8 = lean_array_fset(x_2, x_1, x_7); +x_9 = l_List_foldl___at_Lake_Package_recComputeDeps___spec__7___at_Lake_Package_recComputeDeps___spec__8(x_3, x_6); +x_10 = lean_unsigned_to_nat(1u); +x_11 = lean_nat_add(x_1, x_10); +lean_dec(x_1); +x_1 = x_11; +x_2 = x_8; +x_3 = x_9; +goto _start; +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_expand___at_Lake_Package_recComputeDeps___spec__5(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_3 = lean_array_get_size(x_2); +x_4 = lean_unsigned_to_nat(2u); +x_5 = lean_nat_mul(x_3, x_4); +lean_dec(x_3); +x_6 = lean_box(0); +x_7 = lean_mk_array(x_5, x_6); +x_8 = lean_unsigned_to_nat(0u); +x_9 = l_Lean_HashSetImp_moveEntries___at_Lake_Package_recComputeDeps___spec__6(x_8, x_2, x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_1); +lean_ctor_set(x_10, 1, x_9); +return x_10; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Package_recComputeDeps___spec__9(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_1) == 0) +{ +lean_object* x_4; +lean_dec(x_3); +x_4 = lean_box(0); +return x_4; +} +else +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_1); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_6 = lean_ctor_get(x_1, 0); +x_7 = lean_ctor_get(x_1, 1); +x_8 = lean_ctor_get(x_6, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 2); +lean_inc(x_9); +lean_dec(x_8); +x_10 = lean_ctor_get(x_2, 2); +x_11 = lean_ctor_get(x_10, 2); +x_12 = lean_name_eq(x_9, x_11); +lean_dec(x_9); +if (x_12 == 0) +{ +lean_object* x_13; +x_13 = l_List_replace___at_Lake_Package_recComputeDeps___spec__9(x_7, x_2, x_3); +lean_ctor_set(x_1, 1, x_13); +return x_1; +} +else +{ +lean_dec(x_6); +lean_ctor_set(x_1, 0, x_3); +return x_1; +} +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; +x_14 = lean_ctor_get(x_1, 0); +x_15 = lean_ctor_get(x_1, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_1); +x_16 = lean_ctor_get(x_14, 2); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 2); +lean_inc(x_17); +lean_dec(x_16); +x_18 = lean_ctor_get(x_2, 2); +x_19 = lean_ctor_get(x_18, 2); +x_20 = lean_name_eq(x_17, x_19); +lean_dec(x_17); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = l_List_replace___at_Lake_Package_recComputeDeps___spec__9(x_15, x_2, x_3); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_14); +lean_ctor_set(x_22, 1, x_21); +return x_22; +} +else +{ +lean_object* x_23; +lean_dec(x_14); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_3); +lean_ctor_set(x_23, 1, x_15); +return x_23; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_insert___at_Lake_Package_recComputeDeps___spec__4(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_1); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; size_t x_10; lean_object* x_11; uint8_t x_12; +x_4 = lean_ctor_get(x_1, 0); +x_5 = lean_ctor_get(x_1, 1); +x_6 = lean_array_get_size(x_5); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_7, 2); +lean_inc(x_8); +lean_dec(x_7); +x_9 = l_Lean_Name_hash___override(x_8); +lean_dec(x_8); +lean_inc(x_6); +x_10 = lean_hashset_mk_idx(x_6, x_9); +x_11 = lean_array_uget(x_5, x_10); +x_12 = l_List_elem___at_Lake_Package_recComputeDeps___spec__3(x_2, x_11); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; +x_13 = lean_unsigned_to_nat(1u); +x_14 = lean_nat_add(x_4, x_13); +lean_dec(x_4); +x_15 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_15, 0, x_2); +lean_ctor_set(x_15, 1, x_11); +x_16 = lean_array_uset(x_5, x_10, x_15); +x_17 = lean_nat_dec_le(x_14, x_6); +lean_dec(x_6); +if (x_17 == 0) +{ +lean_object* x_18; +lean_free_object(x_1); +x_18 = l_Lean_HashSetImp_expand___at_Lake_Package_recComputeDeps___spec__5(x_14, x_16); +return x_18; +} +else +{ +lean_ctor_set(x_1, 1, x_16); +lean_ctor_set(x_1, 0, x_14); +return x_1; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +lean_dec(x_6); +x_19 = lean_box(0); +x_20 = lean_array_uset(x_5, x_10, x_19); +lean_inc(x_2); +x_21 = l_List_replace___at_Lake_Package_recComputeDeps___spec__9(x_11, x_2, x_2); +lean_dec(x_2); +x_22 = lean_array_uset(x_20, x_10, x_21); +lean_ctor_set(x_1, 1, x_22); +return x_1; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint64_t x_28; size_t x_29; lean_object* x_30; uint8_t x_31; +x_23 = lean_ctor_get(x_1, 0); +x_24 = lean_ctor_get(x_1, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_1); +x_25 = lean_array_get_size(x_24); +x_26 = lean_ctor_get(x_2, 2); +lean_inc(x_26); +x_27 = lean_ctor_get(x_26, 2); +lean_inc(x_27); +lean_dec(x_26); +x_28 = l_Lean_Name_hash___override(x_27); +lean_dec(x_27); +lean_inc(x_25); +x_29 = lean_hashset_mk_idx(x_25, x_28); +x_30 = lean_array_uget(x_24, x_29); +x_31 = l_List_elem___at_Lake_Package_recComputeDeps___spec__3(x_2, x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_32 = lean_unsigned_to_nat(1u); +x_33 = lean_nat_add(x_23, x_32); +lean_dec(x_23); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_2); +lean_ctor_set(x_34, 1, x_30); +x_35 = lean_array_uset(x_24, x_29, x_34); +x_36 = lean_nat_dec_le(x_33, x_25); +lean_dec(x_25); +if (x_36 == 0) +{ +lean_object* x_37; +x_37 = l_Lean_HashSetImp_expand___at_Lake_Package_recComputeDeps___spec__5(x_33, x_35); +return x_37; +} +else +{ +lean_object* x_38; +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_33); +lean_ctor_set(x_38, 1, x_35); +return x_38; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_dec(x_25); +x_39 = lean_box(0); +x_40 = lean_array_uset(x_24, x_29, x_39); +lean_inc(x_2); +x_41 = l_List_replace___at_Lake_Package_recComputeDeps___spec__9(x_30, x_2, x_2); +lean_dec(x_2); +x_42 = lean_array_uset(x_40, x_29, x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_23); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instHashablePackage___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_instBEqPackage___boxed), 2, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = l_Lean_HashSetImp_contains___at_Lake_Package_recComputeDeps___spec__2(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +lean_inc(x_2); +x_6 = lean_array_push(x_5, x_2); +x_7 = l_Lean_HashSetImp_insert___at_Lake_Package_recComputeDeps___spec__4(x_3, x_2); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +return x_8; +} +else +{ +lean_dec(x_3); +lean_dec(x_2); +return x_1; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_usize_dec_eq(x_2, x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; size_t x_8; size_t x_9; +x_6 = lean_array_uget(x_1, x_2); +x_7 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_4, x_6); +x_8 = 1; +x_9 = lean_usize_add(x_2, x_8); +x_2 = x_9; +x_4 = x_7; +goto _start; +} +else +{ +return x_4; +} +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("deps", 4); +return x_1; +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; uint8_t x_36; +x_36 = lean_usize_dec_eq(x_2, x_3); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_37 = lean_array_uget(x_1, x_2); +x_38 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__2; +lean_inc(x_37); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_40 = lean_apply_6(x_5, x_39, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_40, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_41, 0); +lean_inc(x_42); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_40, 1); +lean_inc(x_43); +lean_dec(x_40); +x_44 = !lean_is_exclusive(x_41); +if (x_44 == 0) +{ +lean_object* x_45; uint8_t x_46; +x_45 = lean_ctor_get(x_41, 0); +lean_dec(x_45); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_array_get_size(x_47); +x_49 = lean_unsigned_to_nat(0u); +x_50 = lean_nat_dec_lt(x_49, x_48); +if (x_50 == 0) +{ +lean_object* x_51; +lean_dec(x_48); +lean_dec(x_47); +x_51 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_4, x_37); +lean_ctor_set(x_42, 0, x_51); +x_11 = x_41; +x_12 = x_43; +goto block_35; +} +else +{ +uint8_t x_52; +x_52 = lean_nat_dec_le(x_48, x_48); +if (x_52 == 0) +{ +lean_object* x_53; +lean_dec(x_48); +lean_dec(x_47); +x_53 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_4, x_37); +lean_ctor_set(x_42, 0, x_53); +x_11 = x_41; +x_12 = x_43; +goto block_35; +} +else +{ +size_t x_54; size_t x_55; lean_object* x_56; lean_object* x_57; +x_54 = 0; +x_55 = lean_usize_of_nat(x_48); +lean_dec(x_48); +x_56 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10(x_47, x_54, x_55, x_4); +lean_dec(x_47); +x_57 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_56, x_37); +lean_ctor_set(x_42, 0, x_57); +x_11 = x_41; +x_12 = x_43; +goto block_35; +} +} +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; +x_58 = lean_ctor_get(x_42, 0); +x_59 = lean_ctor_get(x_42, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_42); +x_60 = lean_array_get_size(x_58); +x_61 = lean_unsigned_to_nat(0u); +x_62 = lean_nat_dec_lt(x_61, x_60); +if (x_62 == 0) +{ +lean_object* x_63; lean_object* x_64; +lean_dec(x_60); +lean_dec(x_58); +x_63 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_4, x_37); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_59); +lean_ctor_set(x_41, 0, x_64); +x_11 = x_41; +x_12 = x_43; +goto block_35; +} +else +{ +uint8_t x_65; +x_65 = lean_nat_dec_le(x_60, x_60); +if (x_65 == 0) +{ +lean_object* x_66; lean_object* x_67; +lean_dec(x_60); +lean_dec(x_58); +x_66 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_4, x_37); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_59); +lean_ctor_set(x_41, 0, x_67); +x_11 = x_41; +x_12 = x_43; +goto block_35; +} +else +{ +size_t x_68; size_t x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_68 = 0; +x_69 = lean_usize_of_nat(x_60); +lean_dec(x_60); +x_70 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10(x_58, x_68, x_69, x_4); +lean_dec(x_58); +x_71 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_70, x_37); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_59); +lean_ctor_set(x_41, 0, x_72); +x_11 = x_41; +x_12 = x_43; +goto block_35; +} +} +} +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; +x_73 = lean_ctor_get(x_41, 1); +lean_inc(x_73); +lean_dec(x_41); +x_74 = lean_ctor_get(x_42, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_42, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_76 = x_42; +} else { + lean_dec_ref(x_42); + x_76 = lean_box(0); +} +x_77 = lean_array_get_size(x_74); +x_78 = lean_unsigned_to_nat(0u); +x_79 = lean_nat_dec_lt(x_78, x_77); +if (x_79 == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; +lean_dec(x_77); +lean_dec(x_74); +x_80 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_4, x_37); +if (lean_is_scalar(x_76)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_76; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_75); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_73); +x_11 = x_82; +x_12 = x_43; +goto block_35; +} +else +{ +uint8_t x_83; +x_83 = lean_nat_dec_le(x_77, x_77); +if (x_83 == 0) +{ +lean_object* x_84; lean_object* x_85; lean_object* x_86; +lean_dec(x_77); +lean_dec(x_74); +x_84 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_4, x_37); +if (lean_is_scalar(x_76)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_76; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_75); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_73); +x_11 = x_86; +x_12 = x_43; +goto block_35; +} +else +{ +size_t x_87; size_t x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_87 = 0; +x_88 = lean_usize_of_nat(x_77); +lean_dec(x_77); +x_89 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10(x_74, x_87, x_88, x_4); +lean_dec(x_74); +x_90 = l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1(x_89, x_37); +if (lean_is_scalar(x_76)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_76; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_75); +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_73); +x_11 = x_92; +x_12 = x_43; +goto block_35; +} +} +} +} +else +{ +lean_object* x_93; uint8_t x_94; +lean_dec(x_37); +lean_dec(x_4); +x_93 = lean_ctor_get(x_40, 1); +lean_inc(x_93); +lean_dec(x_40); +x_94 = !lean_is_exclusive(x_41); +if (x_94 == 0) +{ +lean_object* x_95; uint8_t x_96; +x_95 = lean_ctor_get(x_41, 0); +lean_dec(x_95); +x_96 = !lean_is_exclusive(x_42); +if (x_96 == 0) +{ +x_11 = x_41; +x_12 = x_93; +goto block_35; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_97 = lean_ctor_get(x_42, 0); +x_98 = lean_ctor_get(x_42, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_42); +x_99 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set(x_99, 1, x_98); +lean_ctor_set(x_41, 0, x_99); +x_11 = x_41; +x_12 = x_93; +goto block_35; +} +} +else +{ +lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; +x_100 = lean_ctor_get(x_41, 1); +lean_inc(x_100); +lean_dec(x_41); +x_101 = lean_ctor_get(x_42, 0); +lean_inc(x_101); +x_102 = lean_ctor_get(x_42, 1); +lean_inc(x_102); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_103 = x_42; +} else { + lean_dec_ref(x_42); + x_103 = lean_box(0); +} +if (lean_is_scalar(x_103)) { + x_104 = lean_alloc_ctor(1, 2, 0); +} else { + x_104 = x_103; +} +lean_ctor_set(x_104, 0, x_101); +lean_ctor_set(x_104, 1, x_102); +x_105 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_105, 0, x_104); +lean_ctor_set(x_105, 1, x_100); +x_11 = x_105; +x_12 = x_93; +goto block_35; +} +} +} +else +{ +uint8_t x_106; +lean_dec(x_37); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_106 = !lean_is_exclusive(x_40); +if (x_106 == 0) +{ +return x_40; +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_107 = lean_ctor_get(x_40, 0); +x_108 = lean_ctor_get(x_40, 1); +lean_inc(x_108); +lean_inc(x_107); +lean_dec(x_40); +x_109 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_109, 0, x_107); +lean_ctor_set(x_109, 1, x_108); +return x_109; +} +} +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_110 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_110, 0, x_4); +lean_ctor_set(x_110, 1, x_8); +x_111 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_111, 0, x_110); +lean_ctor_set(x_111, 1, x_9); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_10); +return x_112; +} +block_35: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; size_t x_17; size_t x_18; +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +lean_dec(x_11); +x_15 = lean_ctor_get(x_13, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_13, 1); +lean_inc(x_16); +lean_dec(x_13); +x_17 = 1; +x_18 = lean_usize_add(x_2, x_17); +x_2 = x_18; +x_4 = x_15; +x_8 = x_16; +x_9 = x_14; +x_10 = x_12; +goto _start; +} +else +{ +uint8_t x_20; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_20 = !lean_is_exclusive(x_11); +if (x_20 == 0) +{ +lean_object* x_21; uint8_t x_22; +x_21 = lean_ctor_get(x_11, 0); +lean_dec(x_21); +x_22 = !lean_is_exclusive(x_13); +if (x_22 == 0) +{ +lean_object* x_23; +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_11); +lean_ctor_set(x_23, 1, x_12); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_24 = lean_ctor_get(x_13, 0); +x_25 = lean_ctor_get(x_13, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_13); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +lean_ctor_set(x_11, 0, x_26); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_11); +lean_ctor_set(x_27, 1, x_12); +return x_27; +} +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_28 = lean_ctor_get(x_11, 1); +lean_inc(x_28); +lean_dec(x_11); +x_29 = lean_ctor_get(x_13, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_13, 1); +lean_inc(x_30); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_31 = x_13; +} else { + lean_dec_ref(x_13); + x_31 = lean_box(0); +} +if (lean_is_scalar(x_31)) { + x_32 = lean_alloc_ctor(1, 2, 0); +} else { + x_32 = x_31; +} +lean_ctor_set(x_32, 0, x_29); +lean_ctor_set(x_32, 1, x_30); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_28); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_12); +return x_34; +} +} +} +} +} +static lean_object* _init_l_Lake_Package_recComputeDeps___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recComputeDeps(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; size_t x_10; size_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_8 = lean_ctor_get(x_1, 6); +lean_inc(x_8); +lean_dec(x_1); +x_9 = lean_array_get_size(x_8); +x_10 = lean_usize_of_nat(x_9); +lean_dec(x_9); +x_11 = 0; +x_12 = l_Array_mapMUnsafe_map___at_Lake_Package_deps___spec__1(x_10, x_11, x_8); +x_13 = lean_array_get_size(x_12); +x_14 = lean_unsigned_to_nat(0u); +x_15 = lean_nat_dec_lt(x_14, x_13); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_16 = l_Lake_Package_recComputeDeps___closed__1; +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_5); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_6); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_7); +return x_19; +} +else +{ +uint8_t x_20; +x_20 = lean_nat_dec_le(x_13, x_13); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_21 = l_Lake_Package_recComputeDeps___closed__1; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_5); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_6); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_7); +return x_24; +} +else +{ +size_t x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_usize_of_nat(x_13); +lean_dec(x_13); +x_26 = l_Lake_OrdHashSet_empty___at_Lake_OrdPackageSet_empty___spec__1; +x_27 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11(x_12, x_11, x_25, x_26, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_12); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +if (lean_obj_tag(x_29) == 0) +{ +uint8_t x_30; +x_30 = !lean_is_exclusive(x_27); +if (x_30 == 0) +{ +lean_object* x_31; uint8_t x_32; +x_31 = lean_ctor_get(x_27, 0); +lean_dec(x_31); +x_32 = !lean_is_exclusive(x_28); +if (x_32 == 0) +{ +lean_object* x_33; uint8_t x_34; +x_33 = lean_ctor_get(x_28, 0); +lean_dec(x_33); +x_34 = !lean_is_exclusive(x_29); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_ctor_get(x_29, 0); +x_36 = lean_ctor_get(x_35, 1); +lean_inc(x_36); +lean_dec(x_35); +lean_ctor_set(x_29, 0, x_36); +return x_27; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_37 = lean_ctor_get(x_29, 0); +x_38 = lean_ctor_get(x_29, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_29); +x_39 = lean_ctor_get(x_37, 1); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_38); +lean_ctor_set(x_28, 0, x_40); +return x_27; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_41 = lean_ctor_get(x_28, 1); +lean_inc(x_41); +lean_dec(x_28); +x_42 = lean_ctor_get(x_29, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_29, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_44 = x_29; +} else { + lean_dec_ref(x_29); + x_44 = lean_box(0); +} +x_45 = lean_ctor_get(x_42, 1); +lean_inc(x_45); +lean_dec(x_42); +if (lean_is_scalar(x_44)) { + x_46 = lean_alloc_ctor(0, 2, 0); +} else { + x_46 = x_44; +} +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_43); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_41); +lean_ctor_set(x_27, 0, x_47); +return x_27; +} +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_48 = lean_ctor_get(x_27, 1); +lean_inc(x_48); +lean_dec(x_27); +x_49 = lean_ctor_get(x_28, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_50 = x_28; +} else { + lean_dec_ref(x_28); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_29, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_29, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_53 = x_29; +} else { + lean_dec_ref(x_29); + x_53 = lean_box(0); +} +x_54 = lean_ctor_get(x_51, 1); +lean_inc(x_54); +lean_dec(x_51); +if (lean_is_scalar(x_53)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_53; +} +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_52); +if (lean_is_scalar(x_50)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_50; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_48); +return x_57; +} +} +else +{ +uint8_t x_58; +x_58 = !lean_is_exclusive(x_27); +if (x_58 == 0) +{ +lean_object* x_59; uint8_t x_60; +x_59 = lean_ctor_get(x_27, 0); +lean_dec(x_59); +x_60 = !lean_is_exclusive(x_28); +if (x_60 == 0) +{ +lean_object* x_61; uint8_t x_62; +x_61 = lean_ctor_get(x_28, 0); +lean_dec(x_61); +x_62 = !lean_is_exclusive(x_29); +if (x_62 == 0) +{ +return x_27; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_29, 0); +x_64 = lean_ctor_get(x_29, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_29); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +lean_ctor_set(x_28, 0, x_65); +return x_27; +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_66 = lean_ctor_get(x_28, 1); +lean_inc(x_66); +lean_dec(x_28); +x_67 = lean_ctor_get(x_29, 0); +lean_inc(x_67); +x_68 = lean_ctor_get(x_29, 1); +lean_inc(x_68); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_69 = x_29; +} else { + lean_dec_ref(x_29); + x_69 = lean_box(0); +} +if (lean_is_scalar(x_69)) { + x_70 = lean_alloc_ctor(1, 2, 0); +} else { + x_70 = x_69; +} +lean_ctor_set(x_70, 0, x_67); +lean_ctor_set(x_70, 1, x_68); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_66); +lean_ctor_set(x_27, 0, x_71); +return x_27; +} +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_72 = lean_ctor_get(x_27, 1); +lean_inc(x_72); +lean_dec(x_27); +x_73 = lean_ctor_get(x_28, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_74 = x_28; +} else { + lean_dec_ref(x_28); + x_74 = lean_box(0); +} +x_75 = lean_ctor_get(x_29, 0); +lean_inc(x_75); +x_76 = lean_ctor_get(x_29, 1); +lean_inc(x_76); +if (lean_is_exclusive(x_29)) { + lean_ctor_release(x_29, 0); + lean_ctor_release(x_29, 1); + x_77 = x_29; +} else { + lean_dec_ref(x_29); + x_77 = lean_box(0); +} +if (lean_is_scalar(x_77)) { + x_78 = lean_alloc_ctor(1, 2, 0); +} else { + x_78 = x_77; +} +lean_ctor_set(x_78, 0, x_75); +lean_ctor_set(x_78, 1, x_76); +if (lean_is_scalar(x_74)) { + x_79 = lean_alloc_ctor(0, 2, 0); +} else { + x_79 = x_74; +} +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_73); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_72); +return x_80; +} +} +} +else +{ +uint8_t x_81; +x_81 = !lean_is_exclusive(x_27); +if (x_81 == 0) +{ +return x_27; +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; +x_82 = lean_ctor_get(x_27, 0); +x_83 = lean_ctor_get(x_27, 1); +lean_inc(x_83); +lean_inc(x_82); +lean_dec(x_27); +x_84 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_84, 0, x_82); +lean_ctor_set(x_84, 1, x_83); +return x_84; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_List_elem___at_Lake_Package_recComputeDeps___spec__3___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_List_elem___at_Lake_Package_recComputeDeps___spec__3(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_HashSetImp_contains___at_Lake_Package_recComputeDeps___spec__2___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; lean_object* x_4; +x_3 = l_Lean_HashSetImp_contains___at_Lake_Package_recComputeDeps___spec__2(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +x_4 = lean_box(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_List_replace___at_Lake_Package_recComputeDeps___spec__9___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_replace___at_Lake_Package_recComputeDeps___spec__9(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +size_t x_5; size_t x_6; lean_object* x_7; +x_5 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__10(x_1, x_5, x_6, x_4); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +static lean_object* _init_l_Lake_Package_depsFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_recComputeDeps), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_depsFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_depsFacetConfig___closed__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_depsFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_depsFacetConfig___closed__2; +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("extraDep", 8); +return x_1; +} +} +static lean_object* _init_l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; uint8_t x_54; +x_54 = lean_usize_dec_lt(x_3, x_2); +if (x_54 == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_4); +lean_ctor_set(x_55, 1, x_8); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_58 = lean_array_uget(x_1, x_3); +x_59 = l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__2; +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set(x_60, 1, x_59); +lean_inc(x_5); +lean_inc(x_7); +lean_inc(x_6); +x_61 = lean_apply_6(x_5, x_60, x_6, x_7, x_8, x_9, x_10); +if (lean_obj_tag(x_61) == 0) +{ +lean_object* x_62; lean_object* x_63; +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +if (lean_obj_tag(x_63) == 0) +{ +lean_object* x_64; uint8_t x_65; +x_64 = lean_ctor_get(x_61, 1); +lean_inc(x_64); +lean_dec(x_61); +x_65 = !lean_is_exclusive(x_62); +if (x_65 == 0) +{ +lean_object* x_66; uint8_t x_67; +x_66 = lean_ctor_get(x_62, 0); +lean_dec(x_66); +x_67 = !lean_is_exclusive(x_63); +if (x_67 == 0) +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_63, 0); +x_69 = l_Lake_BuildJob_mix___rarg(x_4, x_68); +x_70 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_63, 0, x_70); +x_11 = x_62; +x_12 = x_64; +goto block_53; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_71 = lean_ctor_get(x_63, 0); +x_72 = lean_ctor_get(x_63, 1); +lean_inc(x_72); +lean_inc(x_71); +lean_dec(x_63); +x_73 = l_Lake_BuildJob_mix___rarg(x_4, x_71); +x_74 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_74, 0, x_73); +x_75 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_72); +lean_ctor_set(x_62, 0, x_75); +x_11 = x_62; +x_12 = x_64; +goto block_53; +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_76 = lean_ctor_get(x_62, 1); +lean_inc(x_76); +lean_dec(x_62); +x_77 = lean_ctor_get(x_63, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_63, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_79 = x_63; +} else { + lean_dec_ref(x_63); + x_79 = lean_box(0); +} +x_80 = l_Lake_BuildJob_mix___rarg(x_4, x_77); +x_81 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_81, 0, x_80); +if (lean_is_scalar(x_79)) { + x_82 = lean_alloc_ctor(0, 2, 0); +} else { + x_82 = x_79; +} +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_78); +x_83 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_76); +x_11 = x_83; +x_12 = x_64; +goto block_53; +} +} +else +{ +lean_object* x_84; uint8_t x_85; +lean_dec(x_4); +x_84 = lean_ctor_get(x_61, 1); +lean_inc(x_84); +lean_dec(x_61); +x_85 = !lean_is_exclusive(x_62); +if (x_85 == 0) +{ +lean_object* x_86; uint8_t x_87; +x_86 = lean_ctor_get(x_62, 0); +lean_dec(x_86); +x_87 = !lean_is_exclusive(x_63); +if (x_87 == 0) +{ +x_11 = x_62; +x_12 = x_84; +goto block_53; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_63, 0); +x_89 = lean_ctor_get(x_63, 1); +lean_inc(x_89); +lean_inc(x_88); +lean_dec(x_63); +x_90 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_90, 0, x_88); +lean_ctor_set(x_90, 1, x_89); +lean_ctor_set(x_62, 0, x_90); +x_11 = x_62; +x_12 = x_84; +goto block_53; +} +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_91 = lean_ctor_get(x_62, 1); +lean_inc(x_91); +lean_dec(x_62); +x_92 = lean_ctor_get(x_63, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_63, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_63)) { + lean_ctor_release(x_63, 0); + lean_ctor_release(x_63, 1); + x_94 = x_63; +} else { + lean_dec_ref(x_63); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_91); +x_11 = x_96; +x_12 = x_84; +goto block_53; +} +} +} +else +{ +uint8_t x_97; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_97 = !lean_is_exclusive(x_61); +if (x_97 == 0) +{ +return x_61; +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_98 = lean_ctor_get(x_61, 0); +x_99 = lean_ctor_get(x_61, 1); +lean_inc(x_99); +lean_inc(x_98); +lean_dec(x_61); +x_100 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_99); +return x_100; +} +} +} +block_53: +{ +lean_object* x_13; +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_15 = !lean_is_exclusive(x_11); +if (x_15 == 0) +{ +lean_object* x_16; uint8_t x_17; +x_16 = lean_ctor_get(x_11, 0); +lean_dec(x_16); +x_17 = !lean_is_exclusive(x_13); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_13, 0); +lean_dec(x_18); +x_19 = lean_ctor_get(x_14, 0); +lean_inc(x_19); +lean_dec(x_14); +lean_ctor_set(x_13, 0, x_19); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_11); +lean_ctor_set(x_20, 1, x_12); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_13, 1); +lean_inc(x_21); +lean_dec(x_13); +x_22 = lean_ctor_get(x_14, 0); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_21); +lean_ctor_set(x_11, 0, x_23); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_11); +lean_ctor_set(x_24, 1, x_12); +return x_24; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_11, 1); +lean_inc(x_25); +lean_dec(x_11); +x_26 = lean_ctor_get(x_13, 1); +lean_inc(x_26); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_27 = x_13; +} else { + lean_dec_ref(x_13); + x_27 = lean_box(0); +} +x_28 = lean_ctor_get(x_14, 0); +lean_inc(x_28); +lean_dec(x_14); +if (lean_is_scalar(x_27)) { + x_29 = lean_alloc_ctor(0, 2, 0); +} else { + x_29 = x_27; +} +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_12); +return x_31; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; size_t x_35; size_t x_36; +x_32 = lean_ctor_get(x_11, 1); +lean_inc(x_32); +lean_dec(x_11); +x_33 = lean_ctor_get(x_13, 1); +lean_inc(x_33); +lean_dec(x_13); +x_34 = lean_ctor_get(x_14, 0); +lean_inc(x_34); +lean_dec(x_14); +x_35 = 1; +x_36 = lean_usize_add(x_3, x_35); +x_3 = x_36; +x_4 = x_34; +x_8 = x_33; +x_9 = x_32; +x_10 = x_12; +goto _start; +} +} +else +{ +uint8_t x_38; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_38 = !lean_is_exclusive(x_11); +if (x_38 == 0) +{ +lean_object* x_39; uint8_t x_40; +x_39 = lean_ctor_get(x_11, 0); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_13); +if (x_40 == 0) +{ +lean_object* x_41; +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_11); +lean_ctor_set(x_41, 1, x_12); +return x_41; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_42 = lean_ctor_get(x_13, 0); +x_43 = lean_ctor_get(x_13, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_13); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +lean_ctor_set(x_11, 0, x_44); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_11); +lean_ctor_set(x_45, 1, x_12); +return x_45; +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_46 = lean_ctor_get(x_11, 1); +lean_inc(x_46); +lean_dec(x_11); +x_47 = lean_ctor_get(x_13, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_13, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_49 = x_13; +} else { + lean_dec_ref(x_13); + x_49 = lean_box(0); +} +if (lean_is_scalar(x_49)) { + x_50 = lean_alloc_ctor(1, 2, 0); +} else { + x_50 = x_49; +} +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_48); +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_46); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_12); +return x_52; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__2(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; uint8_t x_55; +x_55 = lean_usize_dec_lt(x_4, x_3); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_5); +lean_ctor_set(x_56, 1, x_9); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_10); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_11); +return x_58; +} +else +{ +lean_object* x_59; lean_object* x_60; +x_59 = lean_array_uget(x_2, x_4); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_1); +x_60 = l_Lake_Package_fetchTargetJob(x_1, x_59, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_60) == 0) +{ +lean_object* x_61; lean_object* x_62; +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +if (lean_obj_tag(x_62) == 0) +{ +lean_object* x_63; uint8_t x_64; +x_63 = lean_ctor_get(x_60, 1); +lean_inc(x_63); +lean_dec(x_60); +x_64 = !lean_is_exclusive(x_61); +if (x_64 == 0) +{ +lean_object* x_65; uint8_t x_66; +x_65 = lean_ctor_get(x_61, 0); +lean_dec(x_65); +x_66 = !lean_is_exclusive(x_62); +if (x_66 == 0) +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_62, 0); +x_68 = l_Lake_BuildJob_mix___rarg(x_5, x_67); +x_69 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_62, 0, x_69); +x_12 = x_61; +x_13 = x_63; +goto block_54; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_70 = lean_ctor_get(x_62, 0); +x_71 = lean_ctor_get(x_62, 1); +lean_inc(x_71); +lean_inc(x_70); +lean_dec(x_62); +x_72 = l_Lake_BuildJob_mix___rarg(x_5, x_70); +x_73 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_73, 0, x_72); +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_71); +lean_ctor_set(x_61, 0, x_74); +x_12 = x_61; +x_13 = x_63; +goto block_54; +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_75 = lean_ctor_get(x_61, 1); +lean_inc(x_75); +lean_dec(x_61); +x_76 = lean_ctor_get(x_62, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_62, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_62)) { + lean_ctor_release(x_62, 0); + lean_ctor_release(x_62, 1); + x_78 = x_62; +} else { + lean_dec_ref(x_62); + x_78 = lean_box(0); +} +x_79 = l_Lake_BuildJob_mix___rarg(x_5, x_76); +x_80 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_80, 0, x_79); +if (lean_is_scalar(x_78)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_78; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_77); +x_82 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_82, 0, x_81); +lean_ctor_set(x_82, 1, x_75); +x_12 = x_82; +x_13 = x_63; +goto block_54; +} +} +else +{ +lean_object* x_83; uint8_t x_84; +lean_dec(x_5); +x_83 = lean_ctor_get(x_60, 1); +lean_inc(x_83); +lean_dec(x_60); +x_84 = !lean_is_exclusive(x_61); +if (x_84 == 0) +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_61, 0); +lean_dec(x_85); +x_86 = !lean_is_exclusive(x_62); +if (x_86 == 0) +{ +x_12 = x_61; +x_13 = x_83; +goto block_54; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_62, 0); +x_88 = lean_ctor_get(x_62, 1); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_62); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +lean_ctor_set(x_61, 0, x_89); +x_12 = x_61; +x_13 = x_83; +goto block_54; +} +} +else +{ +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_90 = lean_ctor_get(x_61, 1); +lean_inc(x_90); +lean_dec(x_61); +x_91 = lean_ctor_get(x_62, 0); +lean_inc(x_91); +x_92 = lean_ctor_get(x_62, 1); +lean_inc(x_92); +if (lean_is_exclusive(x_62)) { + lean_ctor_release(x_62, 0); + lean_ctor_release(x_62, 1); + x_93 = x_62; +} else { + lean_dec_ref(x_62); + x_93 = lean_box(0); +} +if (lean_is_scalar(x_93)) { + x_94 = lean_alloc_ctor(1, 2, 0); +} else { + x_94 = x_93; +} +lean_ctor_set(x_94, 0, x_91); +lean_ctor_set(x_94, 1, x_92); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_90); +x_12 = x_95; +x_13 = x_83; +goto block_54; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_1); +x_96 = !lean_is_exclusive(x_60); +if (x_96 == 0) +{ +return x_60; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_97 = lean_ctor_get(x_60, 0); +x_98 = lean_ctor_get(x_60, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_60); +x_99 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set(x_99, 1, x_98); +return x_99; +} +} +} +block_54: +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_12, 0); +lean_inc(x_14); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +if (lean_obj_tag(x_15) == 0) +{ +uint8_t x_16; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 0); +lean_inc(x_20); +lean_dec(x_15); +lean_ctor_set(x_14, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_12); +lean_ctor_set(x_21, 1, x_13); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_ctor_get(x_15, 0); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_12); +lean_ctor_set(x_25, 1, x_13); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_dec(x_12); +x_27 = lean_ctor_get(x_14, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_28 = x_14; +} else { + lean_dec_ref(x_14); + x_28 = lean_box(0); +} +x_29 = lean_ctor_get(x_15, 0); +lean_inc(x_29); +lean_dec(x_15); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_13); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; size_t x_36; size_t x_37; +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +lean_dec(x_12); +x_34 = lean_ctor_get(x_14, 1); +lean_inc(x_34); +lean_dec(x_14); +x_35 = lean_ctor_get(x_15, 0); +lean_inc(x_35); +lean_dec(x_15); +x_36 = 1; +x_37 = lean_usize_add(x_4, x_36); +x_4 = x_37; +x_5 = x_35; +x_9 = x_34; +x_10 = x_33; +x_11 = x_13; +goto _start; +} +} +else +{ +uint8_t x_39; +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_39 = !lean_is_exclusive(x_12); +if (x_39 == 0) +{ +lean_object* x_40; uint8_t x_41; +x_40 = lean_ctor_get(x_12, 0); +lean_dec(x_40); +x_41 = !lean_is_exclusive(x_14); +if (x_41 == 0) +{ +lean_object* x_42; +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_12); +lean_ctor_set(x_42, 1, x_13); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_43 = lean_ctor_get(x_14, 0); +x_44 = lean_ctor_get(x_14, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_14); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_12, 0, x_45); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_12); +lean_ctor_set(x_46, 1, x_13); +return x_46; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = lean_ctor_get(x_12, 1); +lean_inc(x_47); +lean_dec(x_12); +x_48 = lean_ctor_get(x_14, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_14, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_14)) { + lean_ctor_release(x_14, 0); + lean_ctor_release(x_14, 1); + x_50 = x_14; +} else { + lean_dec_ref(x_14); + x_50 = lean_box(0); +} +if (lean_is_scalar(x_50)) { + x_51 = lean_alloc_ctor(1, 2, 0); +} else { + x_51 = x_50; +} +lean_ctor_set(x_51, 0, x_48); +lean_ctor_set(x_51, 1, x_49); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_47); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_13); +return x_53; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_recBuildExtraDepTargets___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_recBuildExtraDepTargets___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_recBuildExtraDepTargets___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_ByteArray_empty; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Init.Data.String.Extra", 22); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("String.fromUTF8!", 16); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid UTF-8 string", 20); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5() { +_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_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__2; +x_2 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__3; +x_3 = lean_unsigned_to_nat(92u); +x_4 = lean_unsigned_to_nat(47u); +x_5 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__4; +x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_recBuildExtraDepTargets___spec__4), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_Package_recBuildExtraDepTargets___spec__5(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_recBuildExtraDepTargets___spec__6), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_recBuildExtraDepTargets___spec__4), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_Package_recBuildExtraDepTargets___spec__5(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_recBuildExtraDepTargets___spec__4), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_Package_recBuildExtraDepTargets___spec__5(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_recBuildExtraDepTargets___spec__6), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_recBuildExtraDepTargets___spec__4), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_Package_recBuildExtraDepTargets___spec__5(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Package_recBuildExtraDepTargets___spec__7___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_3); +x_9 = lean_apply_6(x_1, x_3, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 1); +lean_inc(x_13); +lean_dec(x_10); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_11, 1); +lean_inc(x_15); +lean_dec(x_11); +x_16 = lean_apply_7(x_2, x_14, x_3, x_4, x_5, x_15, x_13, x_12); +return x_16; +} +else +{ +uint8_t x_17; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_17 = !lean_is_exclusive(x_9); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_ctor_get(x_9, 0); +lean_dec(x_18); +x_19 = !lean_is_exclusive(x_10); +if (x_19 == 0) +{ +lean_object* x_20; uint8_t x_21; +x_20 = lean_ctor_get(x_10, 0); +lean_dec(x_20); +x_21 = !lean_is_exclusive(x_11); +if (x_21 == 0) +{ +return x_9; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_11); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +lean_ctor_set(x_10, 0, x_24); +return x_9; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 1); +lean_inc(x_25); +lean_dec(x_10); +x_26 = lean_ctor_get(x_11, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_11, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_28 = x_11; +} else { + lean_dec_ref(x_11); + x_28 = lean_box(0); +} +if (lean_is_scalar(x_28)) { + x_29 = lean_alloc_ctor(1, 2, 0); +} else { + x_29 = x_28; +} +lean_ctor_set(x_29, 0, x_26); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_25); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 1); +lean_inc(x_32); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_33 = x_10; +} else { + lean_dec_ref(x_10); + x_33 = lean_box(0); +} +x_34 = lean_ctor_get(x_11, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_11, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_36 = x_11; +} else { + lean_dec_ref(x_11); + x_36 = lean_box(0); +} +if (lean_is_scalar(x_36)) { + x_37 = lean_alloc_ctor(1, 2, 0); +} else { + x_37 = x_36; +} +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_35); +if (lean_is_scalar(x_33)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_33; +} +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_32); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_31); +return x_39; +} +} +} +else +{ +uint8_t x_40; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_40 = !lean_is_exclusive(x_9); +if (x_40 == 0) +{ +return x_9; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_9, 0); +x_42 = lean_ctor_get(x_9, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_9); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_EquipT_bind___at_Lake_Package_recBuildExtraDepTargets___spec__7(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Package_recBuildExtraDepTargets___spec__7___rarg), 8, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; +x_11 = lean_ctor_get(x_1, 2); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 4); +lean_inc(x_12); +lean_dec(x_11); +x_13 = lean_array_get_size(x_12); +x_14 = lean_usize_of_nat(x_13); +lean_dec(x_13); +x_15 = l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__2(x_1, x_12, x_14, x_2, x_3, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_12); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +if (lean_obj_tag(x_17) == 0) +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_15); +if (x_18 == 0) +{ +lean_object* x_19; uint8_t x_20; +x_19 = lean_ctor_get(x_15, 0); +lean_dec(x_19); +x_20 = !lean_is_exclusive(x_16); +if (x_20 == 0) +{ +lean_object* x_21; uint8_t x_22; +x_21 = lean_ctor_get(x_16, 0); +lean_dec(x_21); +x_22 = !lean_is_exclusive(x_17); +if (x_22 == 0) +{ +return x_15; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_17, 0); +x_24 = lean_ctor_get(x_17, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_17); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +lean_ctor_set(x_16, 0, x_25); +return x_15; +} +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_26 = lean_ctor_get(x_16, 1); +lean_inc(x_26); +lean_dec(x_16); +x_27 = lean_ctor_get(x_17, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_17, 1); +lean_inc(x_28); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_29 = x_17; +} else { + lean_dec_ref(x_17); + x_29 = lean_box(0); +} +if (lean_is_scalar(x_29)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_29; +} +lean_ctor_set(x_30, 0, x_27); +lean_ctor_set(x_30, 1, x_28); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_26); +lean_ctor_set(x_15, 0, x_31); +return x_15; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_32 = lean_ctor_get(x_15, 1); +lean_inc(x_32); +lean_dec(x_15); +x_33 = lean_ctor_get(x_16, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_34 = x_16; +} else { + lean_dec_ref(x_16); + x_34 = lean_box(0); +} +x_35 = lean_ctor_get(x_17, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_17, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_37 = x_17; +} else { + lean_dec_ref(x_17); + x_37 = lean_box(0); +} +if (lean_is_scalar(x_37)) { + x_38 = lean_alloc_ctor(0, 2, 0); +} else { + x_38 = x_37; +} +lean_ctor_set(x_38, 0, x_35); +lean_ctor_set(x_38, 1, x_36); +if (lean_is_scalar(x_34)) { + x_39 = lean_alloc_ctor(0, 2, 0); +} else { + x_39 = x_34; +} +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_33); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_32); +return x_40; +} +} +else +{ +uint8_t x_41; +x_41 = !lean_is_exclusive(x_15); +if (x_41 == 0) +{ +lean_object* x_42; uint8_t x_43; +x_42 = lean_ctor_get(x_15, 0); +lean_dec(x_42); +x_43 = !lean_is_exclusive(x_16); +if (x_43 == 0) +{ +lean_object* x_44; uint8_t x_45; +x_44 = lean_ctor_get(x_16, 0); +lean_dec(x_44); +x_45 = !lean_is_exclusive(x_17); +if (x_45 == 0) +{ +return x_15; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_17, 0); +x_47 = lean_ctor_get(x_17, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_17); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +lean_ctor_set(x_16, 0, x_48); +return x_15; +} +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_49 = lean_ctor_get(x_16, 1); +lean_inc(x_49); +lean_dec(x_16); +x_50 = lean_ctor_get(x_17, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_17, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_52 = x_17; +} else { + lean_dec_ref(x_17); + x_52 = lean_box(0); +} +if (lean_is_scalar(x_52)) { + x_53 = lean_alloc_ctor(1, 2, 0); +} else { + x_53 = x_52; +} +lean_ctor_set(x_53, 0, x_50); +lean_ctor_set(x_53, 1, x_51); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_49); +lean_ctor_set(x_15, 0, x_54); +return x_15; +} +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_55 = lean_ctor_get(x_15, 1); +lean_inc(x_55); +lean_dec(x_15); +x_56 = lean_ctor_get(x_16, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_57 = x_16; +} else { + lean_dec_ref(x_16); + x_57 = lean_box(0); +} +x_58 = lean_ctor_get(x_17, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_17, 1); +lean_inc(x_59); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_60 = x_17; +} else { + lean_dec_ref(x_17); + x_60 = lean_box(0); +} +if (lean_is_scalar(x_60)) { + x_61 = lean_alloc_ctor(1, 2, 0); +} else { + x_61 = x_60; +} +lean_ctor_set(x_61, 0, x_58); +lean_ctor_set(x_61, 1, x_59); +if (lean_is_scalar(x_57)) { + x_62 = lean_alloc_ctor(0, 2, 0); +} else { + x_62 = x_57; +} +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_56); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_55); +return x_63; +} +} +} +else +{ +uint8_t x_64; +x_64 = !lean_is_exclusive(x_15); +if (x_64 == 0) +{ +return x_15; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_ctor_get(x_15, 0); +x_66 = lean_ctor_get(x_15, 1); +lean_inc(x_66); +lean_inc(x_65); +lean_dec(x_15); +x_67 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_67, 0, x_65); +lean_ctor_set(x_67, 1, x_66); +return x_67; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_1); +lean_ctor_set(x_6, 1, x_4); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_1); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_4); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_5); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_3, 0); +x_7 = lean_array_push(x_6, x_1); +lean_ctor_set(x_3, 0, x_7); +x_8 = lean_box(0); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_3); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_4); +return x_10; +} +else +{ +lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_11 = lean_ctor_get(x_3, 0); +x_12 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_11); +lean_dec(x_3); +x_13 = lean_array_push(x_11, x_1); +x_14 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set_uint8(x_14, sizeof(void*)*1, x_12); +x_15 = lean_box(0); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_14); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_4); +return x_17; +} +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout/stderr:\n", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("failed to fetch cloud release; falling back to local build", 58); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__4() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 2; +x_2 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__3; +x_3 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_box(0); +x_2 = lean_alloc_closure((void*)(l_ReaderT_pure___at_Lake_buildStaticLib___spec__1___rarg___boxed), 4, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_4 = lean_ctor_get(x_2, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +lean_dec(x_2); +x_52 = lean_ctor_get(x_4, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_4, 1); +lean_inc(x_53); +lean_dec(x_4); +x_54 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets___lambda__3___boxed), 5, 1); +lean_closure_set(x_54, 0, x_53); +x_55 = lean_unbox(x_52); +lean_dec(x_52); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__4; +x_57 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets___lambda__4___boxed), 4, 1); +lean_closure_set(x_57, 0, x_56); +x_58 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_58, 0, x_57); +lean_closure_set(x_58, 1, x_54); +x_6 = x_58; +goto block_51; +} +else +{ +lean_object* x_59; lean_object* x_60; +x_59 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__5; +x_60 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_60, 0, x_59); +lean_closure_set(x_60, 1, x_54); +x_6 = x_60; +goto block_51; +} +block_51: +{ +uint8_t x_7; lean_object* x_8; +x_7 = 1; +lean_inc(x_1); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3(x_6, x_7, x_1, x_5, x_3); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_dec(x_10); +x_15 = l_String_isEmpty(x_13); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; uint8_t x_22; +x_16 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1; +x_17 = lean_string_append(x_16, x_13); +lean_dec(x_13); +x_18 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_19 = lean_string_append(x_17, x_18); +x_20 = 1; +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_20); +x_22 = !lean_is_exclusive(x_12); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_12, 0); +x_24 = lean_array_push(x_23, x_21); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_box(0); +x_26 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_14, x_25, x_1, x_12, x_11); +lean_dec(x_1); +return x_26; +} +else +{ +lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_27 = lean_ctor_get(x_12, 0); +x_28 = lean_ctor_get_uint8(x_12, sizeof(void*)*1); +lean_inc(x_27); +lean_dec(x_12); +x_29 = lean_array_push(x_27, x_21); +x_30 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set_uint8(x_30, sizeof(void*)*1, x_28); +x_31 = lean_box(0); +x_32 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_14, x_31, x_1, x_30, x_11); +lean_dec(x_1); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; +lean_dec(x_13); +x_33 = lean_box(0); +x_34 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_14, x_33, x_1, x_12, x_11); +lean_dec(x_1); +return x_34; +} +} +else +{ +uint8_t x_35; +lean_dec(x_1); +x_35 = !lean_is_exclusive(x_8); +if (x_35 == 0) +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_8, 0); +lean_dec(x_36); +x_37 = !lean_is_exclusive(x_9); +if (x_37 == 0) +{ +return x_8; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_9, 0); +x_39 = lean_ctor_get(x_9, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_9); +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +lean_ctor_set(x_8, 0, x_40); +return x_8; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_41 = lean_ctor_get(x_8, 1); +lean_inc(x_41); +lean_dec(x_8); +x_42 = lean_ctor_get(x_9, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_9, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_44 = x_9; +} else { + lean_dec_ref(x_9); + x_44 = lean_box(0); +} +if (lean_is_scalar(x_44)) { + x_45 = lean_alloc_ctor(1, 2, 0); +} else { + x_45 = x_44; +} +lean_ctor_set(x_45, 0, x_42); +lean_ctor_set(x_45, 1, x_43); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_41); +return x_46; +} +} +} +else +{ +uint8_t x_47; +lean_dec(x_1); +x_47 = !lean_is_exclusive(x_8); +if (x_47 == 0) +{ +return x_8; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_8, 0); +x_49 = lean_ctor_get(x_8, 1); +lean_inc(x_49); +lean_inc(x_48); +lean_dec(x_8); +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_48); +lean_ctor_set(x_50, 1, x_49); +return x_50; +} +} +} +} +else +{ +uint8_t x_61; +lean_dec(x_1); +x_61 = !lean_is_exclusive(x_2); +if (x_61 == 0) +{ +lean_object* x_62; +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_2); +lean_ctor_set(x_62, 1, x_3); +return x_62; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_63 = lean_ctor_get(x_2, 0); +x_64 = lean_ctor_get(x_2, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_2); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_3); +return x_66; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_1); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_9 = lean_ctor_get(x_1, 0); +x_10 = lean_ctor_get(x_1, 1); +x_11 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets___lambda__5), 3, 1); +lean_closure_set(x_11, 0, x_4); +x_12 = l_Task_Priority_default; +x_13 = 0; +x_14 = lean_io_map_task(x_11, x_9, x_12, x_13, x_7); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 0); +lean_ctor_set(x_1, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_1); +lean_ctor_set(x_17, 1, x_5); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_6); +lean_ctor_set(x_14, 0, x_18); +return x_14; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_19 = lean_ctor_get(x_14, 0); +x_20 = lean_ctor_get(x_14, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_14); +lean_ctor_set(x_1, 0, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_1); +lean_ctor_set(x_21, 1, x_5); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_6); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_20); +return x_23; +} +} +else +{ +uint8_t x_24; +lean_free_object(x_1); +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +x_24 = !lean_is_exclusive(x_14); +if (x_24 == 0) +{ +return x_14; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_14, 0); +x_26 = lean_ctor_get(x_14, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_14); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_1, 0); +x_29 = lean_ctor_get(x_1, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_1); +x_30 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets___lambda__5), 3, 1); +lean_closure_set(x_30, 0, x_4); +x_31 = l_Task_Priority_default; +x_32 = 0; +x_33 = lean_io_map_task(x_30, x_28, x_31, x_32, x_7); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_36 = x_33; +} else { + lean_dec_ref(x_33); + x_36 = lean_box(0); +} +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_29); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_5); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_6); +if (lean_is_scalar(x_36)) { + x_40 = lean_alloc_ctor(0, 2, 0); +} else { + x_40 = x_36; +} +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_35); +return x_40; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_29); +lean_dec(x_6); +lean_dec(x_5); +x_41 = lean_ctor_get(x_33, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_33, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_43 = x_33; +} else { + lean_dec_ref(x_33); + x_43 = lean_box(0); +} +if (lean_is_scalar(x_43)) { + x_44 = lean_alloc_ctor(1, 2, 0); +} else { + x_44 = x_43; +} +lean_ctor_set(x_44, 0, x_41); +lean_ctor_set(x_44, 1, x_42); +return x_44; +} +} +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__2() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l_Lake_Package_recComputeDeps___closed__1; +x_2 = 0; +x_3 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_recBuildExtraDepTargets___closed__1; +x_2 = l_Lake_Package_recBuildExtraDepTargets___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Package_recBuildExtraDepTargets___closed__3; +x_2 = lean_task_pure(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_recBuildExtraDepTargets___closed__4; +x_2 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":optRelease", 11); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("optRelease", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_recBuildExtraDepTargets___closed__7; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_recBuildExtraDepTargets___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets___lambda__6___boxed), 7, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; size_t x_10; size_t x_11; lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; +x_8 = lean_ctor_get(x_1, 6); +lean_inc(x_8); +x_9 = lean_array_get_size(x_8); +x_10 = lean_usize_of_nat(x_9); +lean_dec(x_9); +x_11 = 0; +x_12 = l_Array_mapMUnsafe_map___at_Lake_Package_deps___spec__1(x_10, x_11, x_8); +x_13 = lean_array_get_size(x_12); +x_14 = lean_usize_of_nat(x_13); +lean_dec(x_13); +x_15 = l_Lake_Package_recBuildExtraDepTargets___closed__5; +lean_inc(x_4); +lean_inc(x_3); +lean_inc(x_2); +x_16 = l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1(x_12, x_14, x_11, x_15, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_12); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_ctor_get(x_16, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_17, 0); +lean_inc(x_18); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; uint8_t x_30; +x_19 = lean_ctor_get(x_16, 1); +lean_inc(x_19); +lean_dec(x_16); +x_20 = lean_ctor_get(x_17, 1); +lean_inc(x_20); +lean_dec(x_17); +x_21 = lean_ctor_get(x_18, 0); +lean_inc(x_21); +x_22 = lean_ctor_get(x_18, 1); +lean_inc(x_22); +lean_dec(x_18); +x_23 = lean_ctor_get(x_4, 1); +lean_inc(x_23); +x_24 = lean_ctor_get(x_1, 2); +lean_inc(x_24); +x_25 = lean_ctor_get(x_24, 2); +lean_inc(x_25); +x_26 = lean_ctor_get(x_23, 0); +lean_inc(x_26); +lean_dec(x_23); +x_27 = lean_ctor_get(x_26, 2); +lean_inc(x_27); +lean_dec(x_26); +x_28 = lean_ctor_get(x_27, 2); +lean_inc(x_28); +lean_dec(x_27); +x_29 = lean_name_eq(x_25, x_28); +lean_dec(x_28); +x_30 = l_instDecidableNot___rarg(x_29); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_25); +lean_dec(x_24); +x_31 = lean_box(0); +x_32 = l_Lake_Package_recBuildExtraDepTargets___lambda__1(x_1, x_11, x_21, x_31, x_2, x_3, x_4, x_22, x_20, x_19); +return x_32; +} +else +{ +uint8_t x_33; +x_33 = lean_ctor_get_uint8(x_24, sizeof(void*)*21 + 1); +lean_dec(x_24); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; +lean_dec(x_25); +x_34 = lean_box(0); +x_35 = l_Lake_Package_recBuildExtraDepTargets___lambda__1(x_1, x_11, x_21, x_34, x_2, x_3, x_4, x_22, x_20, x_19); +return x_35; +} +else +{ +uint8_t x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_36 = 1; +x_37 = l_Lean_Name_toString(x_25, x_36); +x_38 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_39 = lean_string_append(x_38, x_37); +lean_dec(x_37); +x_40 = l_Lake_Package_recBuildExtraDepTargets___closed__6; +x_41 = lean_string_append(x_39, x_40); +x_42 = l_Lake_Package_recBuildExtraDepTargets___closed__8; +lean_inc(x_1); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_1); +lean_ctor_set(x_43, 1, x_42); +x_44 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_44, 0, x_43); +lean_closure_set(x_44, 1, lean_box(0)); +x_45 = l_Lake_Package_recBuildExtraDepTargets___closed__9; +x_46 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Package_recBuildExtraDepTargets___spec__7___rarg), 8, 2); +lean_closure_set(x_46, 0, x_44); +lean_closure_set(x_46, 1, x_45); +lean_inc(x_4); +lean_inc(x_3); +lean_inc(x_2); +x_47 = l_Lake_withRegisterJob___rarg(x_41, x_46, x_2, x_3, x_4, x_22, x_20, x_19); +if (lean_obj_tag(x_47) == 0) +{ +lean_object* x_48; lean_object* x_49; +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +if (lean_obj_tag(x_49) == 0) +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_50 = lean_ctor_get(x_47, 1); +lean_inc(x_50); +lean_dec(x_47); +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = lean_ctor_get(x_49, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_49, 1); +lean_inc(x_53); +lean_dec(x_49); +x_54 = l_Lake_BuildJob_add___rarg(x_21, x_52); +x_55 = lean_box(0); +x_56 = l_Lake_Package_recBuildExtraDepTargets___lambda__1(x_1, x_11, x_54, x_55, x_2, x_3, x_4, x_53, x_51, x_50); +return x_56; +} +else +{ +uint8_t x_57; +lean_dec(x_21); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_57 = !lean_is_exclusive(x_47); +if (x_57 == 0) +{ +lean_object* x_58; uint8_t x_59; +x_58 = lean_ctor_get(x_47, 0); +lean_dec(x_58); +x_59 = !lean_is_exclusive(x_48); +if (x_59 == 0) +{ +lean_object* x_60; uint8_t x_61; +x_60 = lean_ctor_get(x_48, 0); +lean_dec(x_60); +x_61 = !lean_is_exclusive(x_49); +if (x_61 == 0) +{ +return x_47; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_62 = lean_ctor_get(x_49, 0); +x_63 = lean_ctor_get(x_49, 1); +lean_inc(x_63); +lean_inc(x_62); +lean_dec(x_49); +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set(x_64, 1, x_63); +lean_ctor_set(x_48, 0, x_64); +return x_47; +} +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_65 = lean_ctor_get(x_48, 1); +lean_inc(x_65); +lean_dec(x_48); +x_66 = lean_ctor_get(x_49, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_49, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_49)) { + lean_ctor_release(x_49, 0); + lean_ctor_release(x_49, 1); + x_68 = x_49; +} else { + lean_dec_ref(x_49); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_65); +lean_ctor_set(x_47, 0, x_70); +return x_47; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_71 = lean_ctor_get(x_47, 1); +lean_inc(x_71); +lean_dec(x_47); +x_72 = lean_ctor_get(x_48, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_73 = x_48; +} else { + lean_dec_ref(x_48); + x_73 = lean_box(0); +} +x_74 = lean_ctor_get(x_49, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_49, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_49)) { + lean_ctor_release(x_49, 0); + lean_ctor_release(x_49, 1); + x_76 = x_49; +} else { + lean_dec_ref(x_49); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_76)) { + x_77 = lean_alloc_ctor(1, 2, 0); +} else { + x_77 = x_76; +} +lean_ctor_set(x_77, 0, x_74); +lean_ctor_set(x_77, 1, x_75); +if (lean_is_scalar(x_73)) { + x_78 = lean_alloc_ctor(0, 2, 0); +} else { + x_78 = x_73; +} +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_72); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_71); +return x_79; +} +} +} +else +{ +uint8_t x_80; +lean_dec(x_21); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_80 = !lean_is_exclusive(x_47); +if (x_80 == 0) +{ +return x_47; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_81 = lean_ctor_get(x_47, 0); +x_82 = lean_ctor_get(x_47, 1); +lean_inc(x_82); +lean_inc(x_81); +lean_dec(x_47); +x_83 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_83, 0, x_81); +lean_ctor_set(x_83, 1, x_82); +return x_83; +} +} +} +} +} +else +{ +uint8_t x_84; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_84 = !lean_is_exclusive(x_16); +if (x_84 == 0) +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_16, 0); +lean_dec(x_85); +x_86 = !lean_is_exclusive(x_17); +if (x_86 == 0) +{ +lean_object* x_87; uint8_t x_88; +x_87 = lean_ctor_get(x_17, 0); +lean_dec(x_87); +x_88 = !lean_is_exclusive(x_18); +if (x_88 == 0) +{ +return x_16; +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_89 = lean_ctor_get(x_18, 0); +x_90 = lean_ctor_get(x_18, 1); +lean_inc(x_90); +lean_inc(x_89); +lean_dec(x_18); +x_91 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set(x_91, 1, x_90); +lean_ctor_set(x_17, 0, x_91); +return x_16; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_92 = lean_ctor_get(x_17, 1); +lean_inc(x_92); +lean_dec(x_17); +x_93 = lean_ctor_get(x_18, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_18, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_95 = x_18; +} else { + lean_dec_ref(x_18); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +x_97 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_97, 0, x_96); +lean_ctor_set(x_97, 1, x_92); +lean_ctor_set(x_16, 0, x_97); +return x_16; +} +} +else +{ +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; +x_98 = lean_ctor_get(x_16, 1); +lean_inc(x_98); +lean_dec(x_16); +x_99 = lean_ctor_get(x_17, 1); +lean_inc(x_99); +if (lean_is_exclusive(x_17)) { + lean_ctor_release(x_17, 0); + lean_ctor_release(x_17, 1); + x_100 = x_17; +} else { + lean_dec_ref(x_17); + x_100 = lean_box(0); +} +x_101 = lean_ctor_get(x_18, 0); +lean_inc(x_101); +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_103 = x_18; +} else { + lean_dec_ref(x_18); + x_103 = lean_box(0); +} +if (lean_is_scalar(x_103)) { + x_104 = lean_alloc_ctor(1, 2, 0); +} else { + x_104 = x_103; +} +lean_ctor_set(x_104, 0, x_101); +lean_ctor_set(x_104, 1, x_102); +if (lean_is_scalar(x_100)) { + x_105 = lean_alloc_ctor(0, 2, 0); +} else { + x_105 = x_100; +} +lean_ctor_set(x_105, 0, x_104); +lean_ctor_set(x_105, 1, x_99); +x_106 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_106, 0, x_105); +lean_ctor_set(x_106, 1, x_98); +return x_106; +} +} +} +else +{ +uint8_t x_107; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_107 = !lean_is_exclusive(x_16); +if (x_107 == 0) +{ +return x_16; +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; +x_108 = lean_ctor_get(x_16, 0); +x_109 = lean_ctor_get(x_16, 1); +lean_inc(x_109); +lean_inc(x_108); +lean_dec(x_16); +x_110 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_110, 0, x_108); +lean_ctor_set(x_110, 1, x_109); +return x_110; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; size_t x_12; lean_object* x_13; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1(x_1, x_11, x_12, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_1); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +size_t x_12; size_t x_13; lean_object* x_14; +x_12 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_14 = l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__2(x_1, x_2, x_12, x_13, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +lean_dec(x_2); +return x_14; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +size_t x_11; lean_object* x_12; +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = l_Lake_Package_recBuildExtraDepTargets___lambda__1(x_1, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10); +lean_dec(x_4); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Package_recBuildExtraDepTargets___lambda__3(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Package_recBuildExtraDepTargets___lambda__4(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_recBuildExtraDepTargets___lambda__6___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Package_recBuildExtraDepTargets___lambda__6(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_3); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_dec(x_3); +x_4 = lean_box(0); +lean_ctor_set(x_1, 0, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +} +static lean_object* _init_l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___lambda__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_Package_extraDepFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_extraDepFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Package_extraDepFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_extraDepFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_extraDepFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_extraDepFacetConfig___closed__3; +x_2 = l_Lake_Package_extraDepFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_extraDepFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_extraDepFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_5, 0); +x_9 = l_Lake_download(x_1, x_2, x_8, x_6); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_9); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_9, 0); +lean_dec(x_12); +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; +x_14 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_14); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_10, 0); +x_16 = lean_ctor_get(x_10, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_5); +lean_ctor_set(x_9, 0, x_17); +return x_9; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_18 = lean_ctor_get(x_9, 1); +lean_inc(x_18); +lean_dec(x_9); +x_19 = lean_ctor_get(x_10, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_10, 1); +lean_inc(x_20); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_21 = x_10; +} else { + lean_dec_ref(x_10); + x_21 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_20); +if (lean_is_scalar(x_21)) { + x_22 = lean_alloc_ctor(0, 2, 0); +} else { + x_22 = x_21; +} +lean_ctor_set(x_22, 0, x_19); +lean_ctor_set(x_22, 1, x_5); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_18); +return x_23; +} +} +else +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_9); +if (x_24 == 0) +{ +lean_object* x_25; uint8_t x_26; +x_25 = lean_ctor_get(x_9, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_10); +if (x_26 == 0) +{ +lean_object* x_27; +x_27 = lean_ctor_get(x_10, 1); +lean_ctor_set(x_5, 0, x_27); +lean_ctor_set(x_10, 1, x_5); +return x_9; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_10, 0); +x_29 = lean_ctor_get(x_10, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_10); +lean_ctor_set(x_5, 0, x_29); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_5); +lean_ctor_set(x_9, 0, x_30); +return x_9; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_31 = lean_ctor_get(x_9, 1); +lean_inc(x_31); +lean_dec(x_9); +x_32 = lean_ctor_get(x_10, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_10, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_10)) { + lean_ctor_release(x_10, 0); + lean_ctor_release(x_10, 1); + x_34 = x_10; +} else { + lean_dec_ref(x_10); + x_34 = lean_box(0); +} +lean_ctor_set(x_5, 0, x_33); +if (lean_is_scalar(x_34)) { + x_35 = lean_alloc_ctor(1, 2, 0); +} else { + x_35 = x_34; +} +lean_ctor_set(x_35, 0, x_32); +lean_ctor_set(x_35, 1, x_5); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_31); +return x_36; +} +} +} +else +{ +lean_object* x_37; uint8_t x_38; lean_object* x_39; lean_object* x_40; +x_37 = lean_ctor_get(x_5, 0); +x_38 = lean_ctor_get_uint8(x_5, sizeof(void*)*1); +lean_inc(x_37); +lean_dec(x_5); +x_39 = l_Lake_download(x_1, x_2, x_37, x_6); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_41 = lean_ctor_get(x_39, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_42 = x_39; +} else { + lean_dec_ref(x_39); + x_42 = lean_box(0); +} +x_43 = lean_ctor_get(x_40, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_40, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_45 = x_40; +} else { + lean_dec_ref(x_40); + x_45 = lean_box(0); +} +x_46 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set_uint8(x_46, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_43); +lean_ctor_set(x_47, 1, x_46); +if (lean_is_scalar(x_42)) { + x_48 = lean_alloc_ctor(0, 2, 0); +} else { + x_48 = x_42; +} +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_41); +return x_48; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_49 = lean_ctor_get(x_39, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_39)) { + lean_ctor_release(x_39, 0); + lean_ctor_release(x_39, 1); + x_50 = x_39; +} else { + lean_dec_ref(x_39); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_40, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_40, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_40)) { + lean_ctor_release(x_40, 0); + lean_ctor_release(x_40, 1); + x_53 = x_40; +} else { + lean_dec_ref(x_40); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_38); +if (lean_is_scalar(x_53)) { + x_55 = lean_alloc_ctor(1, 2, 0); +} else { + x_55 = x_53; +} +lean_ctor_set(x_55, 0, x_51); +lean_ctor_set(x_55, 1, x_54); +if (lean_is_scalar(x_50)) { + x_56 = lean_alloc_ctor(0, 2, 0); +} else { + x_56 = x_50; +} +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +return x_56; +} +} +} +} +static uint8_t _init_l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___closed__1() { +_start: +{ +uint32_t x_1; uint8_t x_2; +x_1 = l_Lake_noBuildCode; +x_2 = lean_uint32_to_uint8(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_109; uint8_t x_110; +x_109 = lean_ctor_get(x_7, 0); +lean_inc(x_109); +x_110 = lean_ctor_get_uint8(x_109, sizeof(void*)*1 + 2); +lean_dec(x_109); +if (x_110 == 0) +{ +uint8_t x_111; +x_111 = !lean_is_exclusive(x_8); +if (x_111 == 0) +{ +uint8_t x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_112 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +x_113 = l_Lake_instOrdJobAction; +x_114 = lean_box(x_112); +x_115 = lean_box(x_5); +x_116 = l_instDecidableRelLe___rarg(x_113, x_114, x_115); +if (x_116 == 0) +{ +lean_object* x_117; lean_object* x_118; +x_117 = lean_box(0); +x_118 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_8); +x_10 = x_118; +x_11 = x_9; +goto block_108; +} +else +{ +lean_object* x_119; lean_object* x_120; +lean_ctor_set_uint8(x_8, sizeof(void*)*1, x_5); +x_119 = lean_box(0); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_8); +x_10 = x_120; +x_11 = x_9; +goto block_108; +} +} +else +{ +lean_object* x_121; uint8_t x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; +x_121 = lean_ctor_get(x_8, 0); +x_122 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_121); +lean_dec(x_8); +x_123 = l_Lake_instOrdJobAction; +x_124 = lean_box(x_122); +x_125 = lean_box(x_5); +x_126 = l_instDecidableRelLe___rarg(x_123, x_124, x_125); +if (x_126 == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_127 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_127, 0, x_121); +lean_ctor_set_uint8(x_127, sizeof(void*)*1, x_122); +x_128 = lean_box(0); +x_129 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set(x_129, 1, x_127); +x_10 = x_129; +x_11 = x_9; +goto block_108; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_130, 0, x_121); +lean_ctor_set_uint8(x_130, sizeof(void*)*1, x_5); +x_131 = lean_box(0); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_130); +x_10 = x_132; +x_11 = x_9; +goto block_108; +} +} +} +else +{ +uint8_t x_133; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_133 = !lean_is_exclusive(x_8); +if (x_133 == 0) +{ +lean_object* x_134; uint8_t x_135; lean_object* x_136; +x_134 = lean_ctor_get(x_8, 0); +x_135 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___closed__1; +x_136 = lean_io_exit(x_135, x_9); +if (lean_obj_tag(x_136) == 0) +{ +uint8_t x_137; +x_137 = !lean_is_exclusive(x_136); +if (x_137 == 0) +{ +lean_object* x_138; lean_object* x_139; +x_138 = lean_ctor_get(x_136, 0); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_8); +lean_ctor_set(x_136, 0, x_139); +return x_136; +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_140 = lean_ctor_get(x_136, 0); +x_141 = lean_ctor_get(x_136, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_136); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_140); +lean_ctor_set(x_142, 1, x_8); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_142); +lean_ctor_set(x_143, 1, x_141); +return x_143; +} +} +else +{ +uint8_t x_144; +x_144 = !lean_is_exclusive(x_136); +if (x_144 == 0) +{ +lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_145 = lean_ctor_get(x_136, 0); +x_146 = lean_io_error_to_string(x_145); +x_147 = 3; +x_148 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_148, 0, x_146); +lean_ctor_set_uint8(x_148, sizeof(void*)*1, x_147); +x_149 = lean_array_get_size(x_134); +x_150 = lean_array_push(x_134, x_148); +lean_ctor_set(x_8, 0, x_150); +x_151 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_151, 0, x_149); +lean_ctor_set(x_151, 1, x_8); +lean_ctor_set_tag(x_136, 0); +lean_ctor_set(x_136, 0, x_151); +return x_136; +} +else +{ +lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +x_152 = lean_ctor_get(x_136, 0); +x_153 = lean_ctor_get(x_136, 1); +lean_inc(x_153); +lean_inc(x_152); +lean_dec(x_136); +x_154 = lean_io_error_to_string(x_152); +x_155 = 3; +x_156 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_156, 0, x_154); +lean_ctor_set_uint8(x_156, sizeof(void*)*1, x_155); +x_157 = lean_array_get_size(x_134); +x_158 = lean_array_push(x_134, x_156); +lean_ctor_set(x_8, 0, x_158); +x_159 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_159, 0, x_157); +lean_ctor_set(x_159, 1, x_8); +x_160 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_160, 0, x_159); +lean_ctor_set(x_160, 1, x_153); +return x_160; +} +} +} +else +{ +lean_object* x_161; uint8_t x_162; uint8_t x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_8, 0); +x_162 = lean_ctor_get_uint8(x_8, sizeof(void*)*1); +lean_inc(x_161); +lean_dec(x_8); +x_163 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___closed__1; +x_164 = lean_io_exit(x_163, x_9); +if (lean_obj_tag(x_164) == 0) +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_165 = lean_ctor_get(x_164, 0); +lean_inc(x_165); +x_166 = lean_ctor_get(x_164, 1); +lean_inc(x_166); +if (lean_is_exclusive(x_164)) { + lean_ctor_release(x_164, 0); + lean_ctor_release(x_164, 1); + x_167 = x_164; +} else { + lean_dec_ref(x_164); + x_167 = lean_box(0); +} +x_168 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_168, 0, x_161); +lean_ctor_set_uint8(x_168, sizeof(void*)*1, x_162); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_165); +lean_ctor_set(x_169, 1, x_168); +if (lean_is_scalar(x_167)) { + x_170 = lean_alloc_ctor(0, 2, 0); +} else { + x_170 = x_167; +} +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_166); +return x_170; +} +else +{ +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_171 = lean_ctor_get(x_164, 0); +lean_inc(x_171); +x_172 = lean_ctor_get(x_164, 1); +lean_inc(x_172); +if (lean_is_exclusive(x_164)) { + lean_ctor_release(x_164, 0); + lean_ctor_release(x_164, 1); + x_173 = x_164; +} else { + lean_dec_ref(x_164); + x_173 = lean_box(0); +} +x_174 = lean_io_error_to_string(x_171); +x_175 = 3; +x_176 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_176, 0, x_174); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_175); +x_177 = lean_array_get_size(x_161); +x_178 = lean_array_push(x_161, x_176); +x_179 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_179, 0, x_178); +lean_ctor_set_uint8(x_179, sizeof(void*)*1, x_162); +x_180 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_180, 0, x_177); +lean_ctor_set(x_180, 1, x_179); +if (lean_is_scalar(x_173)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_173; + lean_ctor_set_tag(x_181, 0); +} +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_172); +return x_181; +} +} +} +block_108: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_array_get_size(x_13); +lean_dec(x_13); +x_15 = l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg(x_1, x_2, x_7, x_12, x_11); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +uint8_t x_17; +x_17 = !lean_is_exclusive(x_16); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; +x_18 = lean_ctor_get(x_16, 1); +x_19 = lean_ctor_get(x_16, 0); +lean_dec(x_19); +x_20 = lean_ctor_get(x_15, 1); +lean_inc(x_20); +lean_dec(x_15); +x_21 = !lean_is_exclusive(x_18); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_18, 0); +x_23 = lean_array_get_size(x_22); +x_24 = l_Array_extract___rarg(x_22, x_14, x_23); +x_25 = l_Lake_writeTraceFile(x_3, x_4, x_24, x_20); +if (lean_obj_tag(x_25) == 0) +{ +uint8_t x_26; +lean_dec(x_23); +x_26 = !lean_is_exclusive(x_25); +if (x_26 == 0) +{ +lean_object* x_27; uint8_t x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_25, 0); +lean_dec(x_27); +x_28 = 0; +x_29 = lean_box(x_28); +lean_ctor_set(x_16, 0, x_29); +lean_ctor_set(x_25, 0, x_16); +return x_25; +} +else +{ +lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_25, 1); +lean_inc(x_30); +lean_dec(x_25); +x_31 = 0; +x_32 = lean_box(x_31); +lean_ctor_set(x_16, 0, x_32); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_16); +lean_ctor_set(x_33, 1, x_30); +return x_33; +} +} +else +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_25); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; +x_35 = lean_ctor_get(x_25, 0); +x_36 = lean_io_error_to_string(x_35); +x_37 = 3; +x_38 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set_uint8(x_38, sizeof(void*)*1, x_37); +x_39 = lean_array_push(x_22, x_38); +lean_ctor_set(x_18, 0, x_39); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 0, x_23); +lean_ctor_set_tag(x_25, 0); +lean_ctor_set(x_25, 0, x_16); +return x_25; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_40 = lean_ctor_get(x_25, 0); +x_41 = lean_ctor_get(x_25, 1); +lean_inc(x_41); +lean_inc(x_40); +lean_dec(x_25); +x_42 = lean_io_error_to_string(x_40); +x_43 = 3; +x_44 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set_uint8(x_44, sizeof(void*)*1, x_43); +x_45 = lean_array_push(x_22, x_44); +lean_ctor_set(x_18, 0, x_45); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 0, x_23); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_16); +lean_ctor_set(x_46, 1, x_41); +return x_46; +} +} +} +else +{ +lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_47 = lean_ctor_get(x_18, 0); +x_48 = lean_ctor_get_uint8(x_18, sizeof(void*)*1); +lean_inc(x_47); +lean_dec(x_18); +x_49 = lean_array_get_size(x_47); +x_50 = l_Array_extract___rarg(x_47, x_14, x_49); +x_51 = l_Lake_writeTraceFile(x_3, x_4, x_50, x_20); +if (lean_obj_tag(x_51) == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; +lean_dec(x_49); +x_52 = lean_ctor_get(x_51, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_53 = x_51; +} else { + lean_dec_ref(x_51); + x_53 = lean_box(0); +} +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_47); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_48); +x_55 = 0; +x_56 = lean_box(x_55); +lean_ctor_set(x_16, 1, x_54); +lean_ctor_set(x_16, 0, x_56); +if (lean_is_scalar(x_53)) { + x_57 = lean_alloc_ctor(0, 2, 0); +} else { + x_57 = x_53; +} +lean_ctor_set(x_57, 0, x_16); +lean_ctor_set(x_57, 1, x_52); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_58 = lean_ctor_get(x_51, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_51, 1); +lean_inc(x_59); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_60 = x_51; +} else { + lean_dec_ref(x_51); + x_60 = lean_box(0); +} +x_61 = lean_io_error_to_string(x_58); +x_62 = 3; +x_63 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_63, 0, x_61); +lean_ctor_set_uint8(x_63, sizeof(void*)*1, x_62); +x_64 = lean_array_push(x_47, x_63); +x_65 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set_uint8(x_65, sizeof(void*)*1, x_48); +lean_ctor_set_tag(x_16, 1); +lean_ctor_set(x_16, 1, x_65); +lean_ctor_set(x_16, 0, x_49); +if (lean_is_scalar(x_60)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_60; + lean_ctor_set_tag(x_66, 0); +} +lean_ctor_set(x_66, 0, x_16); +lean_ctor_set(x_66, 1, x_59); +return x_66; +} +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_67 = lean_ctor_get(x_16, 1); +lean_inc(x_67); +lean_dec(x_16); +x_68 = lean_ctor_get(x_15, 1); +lean_inc(x_68); +lean_dec(x_15); +x_69 = lean_ctor_get(x_67, 0); +lean_inc(x_69); +x_70 = lean_ctor_get_uint8(x_67, sizeof(void*)*1); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + x_71 = x_67; +} else { + lean_dec_ref(x_67); + x_71 = lean_box(0); +} +x_72 = lean_array_get_size(x_69); +x_73 = l_Array_extract___rarg(x_69, x_14, x_72); +x_74 = l_Lake_writeTraceFile(x_3, x_4, x_73, x_68); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +lean_dec(x_72); +x_75 = lean_ctor_get(x_74, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_74)) { + lean_ctor_release(x_74, 0); + lean_ctor_release(x_74, 1); + x_76 = x_74; +} else { + lean_dec_ref(x_74); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_71)) { + x_77 = lean_alloc_ctor(0, 1, 1); +} else { + x_77 = x_71; +} +lean_ctor_set(x_77, 0, x_69); +lean_ctor_set_uint8(x_77, sizeof(void*)*1, x_70); +x_78 = 0; +x_79 = lean_box(x_78); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_77); +if (lean_is_scalar(x_76)) { + x_81 = lean_alloc_ctor(0, 2, 0); +} else { + x_81 = x_76; +} +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_75); +return x_81; +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_82 = lean_ctor_get(x_74, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_74, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_74)) { + lean_ctor_release(x_74, 0); + lean_ctor_release(x_74, 1); + x_84 = x_74; +} else { + lean_dec_ref(x_74); + x_84 = lean_box(0); +} +x_85 = lean_io_error_to_string(x_82); +x_86 = 3; +x_87 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set_uint8(x_87, sizeof(void*)*1, x_86); +x_88 = lean_array_push(x_69, x_87); +if (lean_is_scalar(x_71)) { + x_89 = lean_alloc_ctor(0, 1, 1); +} else { + x_89 = x_71; +} +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set_uint8(x_89, sizeof(void*)*1, x_70); +x_90 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_90, 0, x_72); +lean_ctor_set(x_90, 1, x_89); +if (lean_is_scalar(x_84)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_84; + lean_ctor_set_tag(x_91, 0); +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_83); +return x_91; +} +} +} +else +{ +uint8_t x_92; +lean_dec(x_14); +lean_dec(x_4); +lean_dec(x_3); +x_92 = !lean_is_exclusive(x_15); +if (x_92 == 0) +{ +lean_object* x_93; uint8_t x_94; +x_93 = lean_ctor_get(x_15, 0); +lean_dec(x_93); +x_94 = !lean_is_exclusive(x_16); +if (x_94 == 0) +{ +return x_15; +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_95 = lean_ctor_get(x_16, 0); +x_96 = lean_ctor_get(x_16, 1); +lean_inc(x_96); +lean_inc(x_95); +lean_dec(x_16); +x_97 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_97, 0, x_95); +lean_ctor_set(x_97, 1, x_96); +lean_ctor_set(x_15, 0, x_97); +return x_15; +} +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_98 = lean_ctor_get(x_15, 1); +lean_inc(x_98); +lean_dec(x_15); +x_99 = lean_ctor_get(x_16, 0); +lean_inc(x_99); +x_100 = lean_ctor_get(x_16, 1); +lean_inc(x_100); +if (lean_is_exclusive(x_16)) { + lean_ctor_release(x_16, 0); + lean_ctor_release(x_16, 1); + x_101 = x_16; +} else { + lean_dec_ref(x_16); + x_101 = lean_box(0); +} +if (lean_is_scalar(x_101)) { + x_102 = lean_alloc_ctor(1, 2, 0); +} else { + x_102 = x_101; +} +lean_ctor_set(x_102, 0, x_99); +lean_ctor_set(x_102, 1, x_100); +x_103 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_103, 0, x_102); +lean_ctor_set(x_103, 1, x_98); +return x_103; +} +} +} +else +{ +uint8_t x_104; +lean_dec(x_14); +lean_dec(x_4); +lean_dec(x_3); +x_104 = !lean_is_exclusive(x_15); +if (x_104 == 0) +{ +return x_15; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_105 = lean_ctor_get(x_15, 0); +x_106 = lean_ctor_get(x_15, 1); +lean_inc(x_106); +lean_inc(x_105); +lean_dec(x_15); +x_107 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_107, 0, x_105); +lean_ctor_set(x_107, 1, x_106); +return x_107; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, uint8_t x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_330; +x_12 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets___lambda__4___boxed), 4, 1); +lean_closure_set(x_12, 0, x_3); +x_13 = lean_alloc_closure((void*)(l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__1___boxed), 6, 2); +lean_closure_set(x_13, 0, x_1); +lean_closure_set(x_13, 1, x_2); +x_330 = !lean_is_exclusive(x_10); +if (x_330 == 0) +{ +lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; +x_331 = lean_ctor_get(x_10, 0); +x_332 = l_Lake_readTraceFile_x3f(x_6, x_331, x_11); +x_333 = lean_ctor_get(x_332, 0); +lean_inc(x_333); +x_334 = lean_ctor_get(x_332, 1); +lean_inc(x_334); +lean_dec(x_332); +x_335 = !lean_is_exclusive(x_333); +if (x_335 == 0) +{ +lean_object* x_336; +x_336 = lean_ctor_get(x_333, 1); +lean_ctor_set(x_10, 0, x_336); +lean_ctor_set(x_333, 1, x_10); +x_14 = x_333; +x_15 = x_334; +goto block_329; +} +else +{ +lean_object* x_337; lean_object* x_338; lean_object* x_339; +x_337 = lean_ctor_get(x_333, 0); +x_338 = lean_ctor_get(x_333, 1); +lean_inc(x_338); +lean_inc(x_337); +lean_dec(x_333); +lean_ctor_set(x_10, 0, x_338); +x_339 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_339, 0, x_337); +lean_ctor_set(x_339, 1, x_10); +x_14 = x_339; +x_15 = x_334; +goto block_329; +} +} +else +{ +lean_object* x_340; uint8_t 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; +x_340 = lean_ctor_get(x_10, 0); +x_341 = lean_ctor_get_uint8(x_10, sizeof(void*)*1); +lean_inc(x_340); +lean_dec(x_10); +x_342 = l_Lake_readTraceFile_x3f(x_6, x_340, x_11); +x_343 = lean_ctor_get(x_342, 0); +lean_inc(x_343); +x_344 = lean_ctor_get(x_342, 1); +lean_inc(x_344); +lean_dec(x_342); +x_345 = lean_ctor_get(x_343, 0); +lean_inc(x_345); +x_346 = lean_ctor_get(x_343, 1); +lean_inc(x_346); +if (lean_is_exclusive(x_343)) { + lean_ctor_release(x_343, 0); + lean_ctor_release(x_343, 1); + x_347 = x_343; +} else { + lean_dec_ref(x_343); + x_347 = lean_box(0); +} +x_348 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_348, 0, x_346); +lean_ctor_set_uint8(x_348, sizeof(void*)*1, x_341); +if (lean_is_scalar(x_347)) { + x_349 = lean_alloc_ctor(0, 2, 0); +} else { + x_349 = x_347; +} +lean_ctor_set(x_349, 0, x_345); +lean_ctor_set(x_349, 1, x_348); +x_14 = x_349; +x_15 = x_344; +goto block_329; +} +block_329: +{ +lean_object* x_16; +x_16 = lean_ctor_get(x_14, 0); +lean_inc(x_16); +if (lean_obj_tag(x_16) == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_9, 0); +lean_inc(x_17); +x_18 = lean_ctor_get_uint8(x_17, sizeof(void*)*1); +lean_dec(x_17); +if (x_18 == 0) +{ +uint8_t x_19; +lean_dec(x_8); +x_19 = !lean_is_exclusive(x_14); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_14, 1); +x_21 = lean_ctor_get(x_14, 0); +lean_dec(x_21); +x_22 = !lean_is_exclusive(x_20); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_5, 1); +lean_inc(x_23); +x_24 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_4, x_23, x_15); +x_25 = !lean_is_exclusive(x_24); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; uint8_t x_28; +x_26 = lean_ctor_get(x_24, 0); +x_27 = lean_ctor_get(x_24, 1); +x_28 = lean_unbox(x_26); +lean_dec(x_26); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +lean_free_object(x_24); +lean_free_object(x_14); +x_29 = lean_box(0); +x_30 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_29, x_9, x_20, x_27); +return x_30; +} +else +{ +uint8_t x_31; lean_object* x_32; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_31 = 1; +x_32 = lean_box(x_31); +lean_ctor_set(x_14, 0, x_32); +lean_ctor_set(x_24, 0, x_14); +return x_24; +} +} +else +{ +lean_object* x_33; lean_object* x_34; uint8_t x_35; +x_33 = lean_ctor_get(x_24, 0); +x_34 = lean_ctor_get(x_24, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_24); +x_35 = lean_unbox(x_33); +lean_dec(x_33); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; +lean_free_object(x_14); +x_36 = lean_box(0); +x_37 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_36, x_9, x_20, x_34); +return x_37; +} +else +{ +uint8_t x_38; lean_object* x_39; lean_object* x_40; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_38 = 1; +x_39 = lean_box(x_38); +lean_ctor_set(x_14, 0, x_39); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_14); +lean_ctor_set(x_40, 1, x_34); +return x_40; +} +} +} +else +{ +lean_object* x_41; uint8_t x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_41 = lean_ctor_get(x_20, 0); +x_42 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_41); +lean_dec(x_20); +x_43 = lean_ctor_get(x_5, 1); +lean_inc(x_43); +x_44 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_4, x_43, x_15); +x_45 = lean_ctor_get(x_44, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_47 = x_44; +} else { + lean_dec_ref(x_44); + x_47 = lean_box(0); +} +x_48 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_48, 0, x_41); +lean_ctor_set_uint8(x_48, sizeof(void*)*1, x_42); +x_49 = lean_unbox(x_45); +lean_dec(x_45); +if (x_49 == 0) +{ +lean_object* x_50; lean_object* x_51; +lean_dec(x_47); +lean_free_object(x_14); +x_50 = lean_box(0); +x_51 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_50, x_9, x_48, x_46); +return x_51; +} +else +{ +uint8_t x_52; lean_object* x_53; lean_object* x_54; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_52 = 1; +x_53 = lean_box(x_52); +lean_ctor_set(x_14, 1, x_48); +lean_ctor_set(x_14, 0, x_53); +if (lean_is_scalar(x_47)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_47; +} +lean_ctor_set(x_54, 0, x_14); +lean_ctor_set(x_54, 1, x_46); +return x_54; +} +} +} +else +{ +lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; +x_55 = lean_ctor_get(x_14, 1); +lean_inc(x_55); +lean_dec(x_14); +x_56 = lean_ctor_get(x_55, 0); +lean_inc(x_56); +x_57 = lean_ctor_get_uint8(x_55, sizeof(void*)*1); +if (lean_is_exclusive(x_55)) { + lean_ctor_release(x_55, 0); + x_58 = x_55; +} else { + lean_dec_ref(x_55); + x_58 = lean_box(0); +} +x_59 = lean_ctor_get(x_5, 1); +lean_inc(x_59); +x_60 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_4, x_59, x_15); +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_60, 1); +lean_inc(x_62); +if (lean_is_exclusive(x_60)) { + lean_ctor_release(x_60, 0); + lean_ctor_release(x_60, 1); + x_63 = x_60; +} else { + lean_dec_ref(x_60); + x_63 = lean_box(0); +} +if (lean_is_scalar(x_58)) { + x_64 = lean_alloc_ctor(0, 1, 1); +} else { + x_64 = x_58; +} +lean_ctor_set(x_64, 0, x_56); +lean_ctor_set_uint8(x_64, sizeof(void*)*1, x_57); +x_65 = lean_unbox(x_61); +lean_dec(x_61); +if (x_65 == 0) +{ +lean_object* x_66; lean_object* x_67; +lean_dec(x_63); +x_66 = lean_box(0); +x_67 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_66, x_9, x_64, x_62); +return x_67; +} +else +{ +uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_68 = 1; +x_69 = lean_box(x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_64); +if (lean_is_scalar(x_63)) { + x_71 = lean_alloc_ctor(0, 2, 0); +} else { + x_71 = x_63; +} +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_62); +return x_71; +} +} +} +else +{ +uint8_t x_72; +x_72 = !lean_is_exclusive(x_14); +if (x_72 == 0) +{ +lean_object* x_73; lean_object* x_74; uint8_t x_75; +x_73 = lean_ctor_get(x_14, 1); +x_74 = lean_ctor_get(x_14, 0); +lean_dec(x_74); +x_75 = !lean_is_exclusive(x_73); +if (x_75 == 0) +{ +lean_object* x_76; uint8_t x_77; +x_76 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_4, x_8, x_15); +x_77 = !lean_is_exclusive(x_76); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_76, 0); +x_79 = lean_ctor_get(x_76, 1); +x_80 = lean_unbox(x_78); +lean_dec(x_78); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +lean_free_object(x_76); +lean_free_object(x_14); +x_81 = lean_box(0); +x_82 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_81, x_9, x_73, x_79); +return x_82; +} +else +{ +uint8_t x_83; lean_object* x_84; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_83 = 1; +x_84 = lean_box(x_83); +lean_ctor_set(x_14, 0, x_84); +lean_ctor_set(x_76, 0, x_14); +return x_76; +} +} +else +{ +lean_object* x_85; lean_object* x_86; uint8_t x_87; +x_85 = lean_ctor_get(x_76, 0); +x_86 = lean_ctor_get(x_76, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_76); +x_87 = lean_unbox(x_85); +lean_dec(x_85); +if (x_87 == 0) +{ +lean_object* x_88; lean_object* x_89; +lean_free_object(x_14); +x_88 = lean_box(0); +x_89 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_88, x_9, x_73, x_86); +return x_89; +} +else +{ +uint8_t x_90; lean_object* x_91; lean_object* x_92; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_90 = 1; +x_91 = lean_box(x_90); +lean_ctor_set(x_14, 0, x_91); +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_14); +lean_ctor_set(x_92, 1, x_86); +return x_92; +} +} +} +else +{ +lean_object* x_93; uint8_t x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; +x_93 = lean_ctor_get(x_73, 0); +x_94 = lean_ctor_get_uint8(x_73, sizeof(void*)*1); +lean_inc(x_93); +lean_dec(x_73); +x_95 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_4, x_8, x_15); +x_96 = lean_ctor_get(x_95, 0); +lean_inc(x_96); +x_97 = lean_ctor_get(x_95, 1); +lean_inc(x_97); +if (lean_is_exclusive(x_95)) { + lean_ctor_release(x_95, 0); + lean_ctor_release(x_95, 1); + x_98 = x_95; +} else { + lean_dec_ref(x_95); + x_98 = lean_box(0); +} +x_99 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_99, 0, x_93); +lean_ctor_set_uint8(x_99, sizeof(void*)*1, x_94); +x_100 = lean_unbox(x_96); +lean_dec(x_96); +if (x_100 == 0) +{ +lean_object* x_101; lean_object* x_102; +lean_dec(x_98); +lean_free_object(x_14); +x_101 = lean_box(0); +x_102 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_101, x_9, x_99, x_97); +return x_102; +} +else +{ +uint8_t x_103; lean_object* x_104; lean_object* x_105; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_103 = 1; +x_104 = lean_box(x_103); +lean_ctor_set(x_14, 1, x_99); +lean_ctor_set(x_14, 0, x_104); +if (lean_is_scalar(x_98)) { + x_105 = lean_alloc_ctor(0, 2, 0); +} else { + x_105 = x_98; +} +lean_ctor_set(x_105, 0, x_14); +lean_ctor_set(x_105, 1, x_97); +return x_105; +} +} +} +else +{ +lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; uint8_t x_115; +x_106 = lean_ctor_get(x_14, 1); +lean_inc(x_106); +lean_dec(x_14); +x_107 = lean_ctor_get(x_106, 0); +lean_inc(x_107); +x_108 = lean_ctor_get_uint8(x_106, sizeof(void*)*1); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + x_109 = x_106; +} else { + lean_dec_ref(x_106); + x_109 = lean_box(0); +} +x_110 = l_Lake_MTime_checkUpToDate___at_Lake_buildFileUnlessUpToDate___spec__3(x_4, x_8, x_15); +x_111 = lean_ctor_get(x_110, 0); +lean_inc(x_111); +x_112 = lean_ctor_get(x_110, 1); +lean_inc(x_112); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_113 = x_110; +} else { + lean_dec_ref(x_110); + x_113 = lean_box(0); +} +if (lean_is_scalar(x_109)) { + x_114 = lean_alloc_ctor(0, 1, 1); +} else { + x_114 = x_109; +} +lean_ctor_set(x_114, 0, x_107); +lean_ctor_set_uint8(x_114, sizeof(void*)*1, x_108); +x_115 = lean_unbox(x_111); +lean_dec(x_111); +if (x_115 == 0) +{ +lean_object* x_116; lean_object* x_117; +lean_dec(x_113); +x_116 = lean_box(0); +x_117 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_116, x_9, x_114, x_112); +return x_117; +} +else +{ +uint8_t x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_118 = 1; +x_119 = lean_box(x_118); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_114); +if (lean_is_scalar(x_113)) { + x_121 = lean_alloc_ctor(0, 2, 0); +} else { + x_121 = x_113; +} +lean_ctor_set(x_121, 0, x_120); +lean_ctor_set(x_121, 1, x_112); +return x_121; +} +} +} +} +else +{ +uint8_t x_122; +x_122 = !lean_is_exclusive(x_16); +if (x_122 == 0) +{ +lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; +x_123 = lean_ctor_get(x_16, 0); +x_124 = lean_ctor_get(x_14, 1); +lean_inc(x_124); +lean_dec(x_14); +x_125 = lean_ctor_get(x_123, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +lean_ctor_set(x_16, 0, x_125); +lean_inc(x_5); +x_127 = l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(x_4, x_5, x_16, x_8, x_9, x_124, x_15); +x_128 = lean_ctor_get(x_127, 0); +lean_inc(x_128); +x_129 = lean_ctor_get(x_127, 1); +lean_inc(x_129); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + lean_ctor_release(x_127, 1); + x_130 = x_127; +} else { + lean_dec_ref(x_127); + x_130 = lean_box(0); +} +x_131 = !lean_is_exclusive(x_128); +if (x_131 == 0) +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_198; +x_132 = lean_ctor_get(x_128, 0); +x_133 = lean_ctor_get(x_128, 1); +x_198 = lean_unbox(x_132); +lean_dec(x_132); +if (x_198 == 0) +{ +lean_object* x_199; lean_object* x_200; +lean_free_object(x_128); +lean_dec(x_130); +lean_dec(x_126); +x_199 = lean_box(0); +x_200 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_199, x_9, x_133, x_129); +return x_200; +} +else +{ +uint8_t x_201; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_6); +lean_dec(x_5); +x_201 = !lean_is_exclusive(x_133); +if (x_201 == 0) +{ +uint8_t x_202; lean_object* x_203; uint8_t x_204; lean_object* x_205; lean_object* x_206; uint8_t x_207; +x_202 = lean_ctor_get_uint8(x_133, sizeof(void*)*1); +x_203 = l_Lake_instOrdJobAction; +x_204 = 1; +x_205 = lean_box(x_202); +x_206 = lean_box(x_204); +x_207 = l_instDecidableRelLe___rarg(x_203, x_205, x_206); +if (x_207 == 0) +{ +lean_object* x_208; +x_208 = lean_box(0); +lean_ctor_set(x_128, 0, x_208); +x_134 = x_128; +x_135 = x_129; +goto block_197; +} +else +{ +lean_object* x_209; +lean_ctor_set_uint8(x_133, sizeof(void*)*1, x_204); +x_209 = lean_box(0); +lean_ctor_set(x_128, 0, x_209); +x_134 = x_128; +x_135 = x_129; +goto block_197; +} +} +else +{ +lean_object* x_210; uint8_t x_211; lean_object* x_212; uint8_t x_213; lean_object* x_214; lean_object* x_215; uint8_t x_216; +x_210 = lean_ctor_get(x_133, 0); +x_211 = lean_ctor_get_uint8(x_133, sizeof(void*)*1); +lean_inc(x_210); +lean_dec(x_133); +x_212 = l_Lake_instOrdJobAction; +x_213 = 1; +x_214 = lean_box(x_211); +x_215 = lean_box(x_213); +x_216 = l_instDecidableRelLe___rarg(x_212, x_214, x_215); +if (x_216 == 0) +{ +lean_object* x_217; lean_object* x_218; +x_217 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_217, 0, x_210); +lean_ctor_set_uint8(x_217, sizeof(void*)*1, x_211); +x_218 = lean_box(0); +lean_ctor_set(x_128, 1, x_217); +lean_ctor_set(x_128, 0, x_218); +x_134 = x_128; +x_135 = x_129; +goto block_197; +} +else +{ +lean_object* x_219; lean_object* x_220; +x_219 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_219, 0, x_210); +lean_ctor_set_uint8(x_219, sizeof(void*)*1, x_213); +x_220 = lean_box(0); +lean_ctor_set(x_128, 1, x_219); +lean_ctor_set(x_128, 0, x_220); +x_134 = x_128; +x_135 = x_129; +goto block_197; +} +} +} +block_197: +{ +uint8_t x_136; +x_136 = !lean_is_exclusive(x_134); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; uint8_t x_141; +x_137 = lean_ctor_get(x_134, 1); +x_138 = lean_ctor_get(x_134, 0); +lean_dec(x_138); +x_139 = lean_array_get_size(x_126); +x_140 = lean_unsigned_to_nat(0u); +x_141 = lean_nat_dec_lt(x_140, x_139); +if (x_141 == 0) +{ +uint8_t x_142; lean_object* x_143; lean_object* x_144; +lean_dec(x_139); +lean_dec(x_126); +lean_dec(x_9); +x_142 = 1; +x_143 = lean_box(x_142); +lean_ctor_set(x_134, 0, x_143); +if (lean_is_scalar(x_130)) { + x_144 = lean_alloc_ctor(0, 2, 0); +} else { + x_144 = x_130; +} +lean_ctor_set(x_144, 0, x_134); +lean_ctor_set(x_144, 1, x_135); +return x_144; +} +else +{ +uint8_t x_145; +x_145 = lean_nat_dec_le(x_139, x_139); +if (x_145 == 0) +{ +uint8_t x_146; lean_object* x_147; lean_object* x_148; +lean_dec(x_139); +lean_dec(x_126); +lean_dec(x_9); +x_146 = 1; +x_147 = lean_box(x_146); +lean_ctor_set(x_134, 0, x_147); +if (lean_is_scalar(x_130)) { + x_148 = lean_alloc_ctor(0, 2, 0); +} else { + x_148 = x_130; +} +lean_ctor_set(x_148, 0, x_134); +lean_ctor_set(x_148, 1, x_135); +return x_148; +} +else +{ +size_t x_149; size_t x_150; lean_object* x_151; lean_object* x_152; uint8_t x_153; +lean_free_object(x_134); +lean_dec(x_130); +x_149 = 0; +x_150 = lean_usize_of_nat(x_139); +lean_dec(x_139); +x_151 = lean_box(0); +x_152 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_126, x_149, x_150, x_151, x_9, x_137, x_135); +lean_dec(x_9); +lean_dec(x_126); +x_153 = !lean_is_exclusive(x_152); +if (x_153 == 0) +{ +lean_object* x_154; uint8_t x_155; +x_154 = lean_ctor_get(x_152, 0); +x_155 = !lean_is_exclusive(x_154); +if (x_155 == 0) +{ +lean_object* x_156; uint8_t x_157; lean_object* x_158; +x_156 = lean_ctor_get(x_154, 0); +lean_dec(x_156); +x_157 = 1; +x_158 = lean_box(x_157); +lean_ctor_set(x_154, 0, x_158); +return x_152; +} +else +{ +lean_object* x_159; uint8_t x_160; lean_object* x_161; lean_object* x_162; +x_159 = lean_ctor_get(x_154, 1); +lean_inc(x_159); +lean_dec(x_154); +x_160 = 1; +x_161 = lean_box(x_160); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_159); +lean_ctor_set(x_152, 0, x_162); +return x_152; +} +} +else +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; uint8_t x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_163 = lean_ctor_get(x_152, 0); +x_164 = lean_ctor_get(x_152, 1); +lean_inc(x_164); +lean_inc(x_163); +lean_dec(x_152); +x_165 = lean_ctor_get(x_163, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_163)) { + lean_ctor_release(x_163, 0); + lean_ctor_release(x_163, 1); + x_166 = x_163; +} else { + lean_dec_ref(x_163); + x_166 = lean_box(0); +} +x_167 = 1; +x_168 = lean_box(x_167); +if (lean_is_scalar(x_166)) { + x_169 = lean_alloc_ctor(0, 2, 0); +} else { + x_169 = x_166; +} +lean_ctor_set(x_169, 0, x_168); +lean_ctor_set(x_169, 1, x_165); +x_170 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_170, 0, x_169); +lean_ctor_set(x_170, 1, x_164); +return x_170; +} +} +} +} +else +{ +lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; +x_171 = lean_ctor_get(x_134, 1); +lean_inc(x_171); +lean_dec(x_134); +x_172 = lean_array_get_size(x_126); +x_173 = lean_unsigned_to_nat(0u); +x_174 = lean_nat_dec_lt(x_173, x_172); +if (x_174 == 0) +{ +uint8_t x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; +lean_dec(x_172); +lean_dec(x_126); +lean_dec(x_9); +x_175 = 1; +x_176 = lean_box(x_175); +x_177 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_177, 0, x_176); +lean_ctor_set(x_177, 1, x_171); +if (lean_is_scalar(x_130)) { + x_178 = lean_alloc_ctor(0, 2, 0); +} else { + x_178 = x_130; +} +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_135); +return x_178; +} +else +{ +uint8_t x_179; +x_179 = lean_nat_dec_le(x_172, x_172); +if (x_179 == 0) +{ +uint8_t x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_172); +lean_dec(x_126); +lean_dec(x_9); +x_180 = 1; +x_181 = lean_box(x_180); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_171); +if (lean_is_scalar(x_130)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_130; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_135); +return x_183; +} +else +{ +size_t x_184; size_t x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; uint8_t x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; +lean_dec(x_130); +x_184 = 0; +x_185 = lean_usize_of_nat(x_172); +lean_dec(x_172); +x_186 = lean_box(0); +x_187 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_126, x_184, x_185, x_186, x_9, x_171, x_135); +lean_dec(x_9); +lean_dec(x_126); +x_188 = lean_ctor_get(x_187, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_187, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_187)) { + lean_ctor_release(x_187, 0); + lean_ctor_release(x_187, 1); + x_190 = x_187; +} else { + lean_dec_ref(x_187); + x_190 = lean_box(0); +} +x_191 = lean_ctor_get(x_188, 1); +lean_inc(x_191); +if (lean_is_exclusive(x_188)) { + lean_ctor_release(x_188, 0); + lean_ctor_release(x_188, 1); + x_192 = x_188; +} else { + lean_dec_ref(x_188); + x_192 = lean_box(0); +} +x_193 = 1; +x_194 = lean_box(x_193); +if (lean_is_scalar(x_192)) { + x_195 = lean_alloc_ctor(0, 2, 0); +} else { + x_195 = x_192; +} +lean_ctor_set(x_195, 0, x_194); +lean_ctor_set(x_195, 1, x_191); +if (lean_is_scalar(x_190)) { + x_196 = lean_alloc_ctor(0, 2, 0); +} else { + x_196 = x_190; +} +lean_ctor_set(x_196, 0, x_195); +lean_ctor_set(x_196, 1, x_189); +return x_196; +} +} +} +} +} +else +{ +lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_253; +x_221 = lean_ctor_get(x_128, 0); +x_222 = lean_ctor_get(x_128, 1); +lean_inc(x_222); +lean_inc(x_221); +lean_dec(x_128); +x_253 = lean_unbox(x_221); +lean_dec(x_221); +if (x_253 == 0) +{ +lean_object* x_254; lean_object* x_255; +lean_dec(x_130); +lean_dec(x_126); +x_254 = lean_box(0); +x_255 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_254, x_9, x_222, x_129); +return x_255; +} +else +{ +lean_object* x_256; uint8_t x_257; lean_object* x_258; lean_object* x_259; uint8_t x_260; lean_object* x_261; lean_object* x_262; uint8_t x_263; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_6); +lean_dec(x_5); +x_256 = lean_ctor_get(x_222, 0); +lean_inc(x_256); +x_257 = lean_ctor_get_uint8(x_222, sizeof(void*)*1); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + x_258 = x_222; +} else { + lean_dec_ref(x_222); + x_258 = lean_box(0); +} +x_259 = l_Lake_instOrdJobAction; +x_260 = 1; +x_261 = lean_box(x_257); +x_262 = lean_box(x_260); +x_263 = l_instDecidableRelLe___rarg(x_259, x_261, x_262); +if (x_263 == 0) +{ +lean_object* x_264; lean_object* x_265; lean_object* x_266; +if (lean_is_scalar(x_258)) { + x_264 = lean_alloc_ctor(0, 1, 1); +} else { + x_264 = x_258; +} +lean_ctor_set(x_264, 0, x_256); +lean_ctor_set_uint8(x_264, sizeof(void*)*1, x_257); +x_265 = lean_box(0); +x_266 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_266, 0, x_265); +lean_ctor_set(x_266, 1, x_264); +x_223 = x_266; +x_224 = x_129; +goto block_252; +} +else +{ +lean_object* x_267; lean_object* x_268; lean_object* x_269; +if (lean_is_scalar(x_258)) { + x_267 = lean_alloc_ctor(0, 1, 1); +} else { + x_267 = x_258; +} +lean_ctor_set(x_267, 0, x_256); +lean_ctor_set_uint8(x_267, sizeof(void*)*1, x_260); +x_268 = lean_box(0); +x_269 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_269, 0, x_268); +lean_ctor_set(x_269, 1, x_267); +x_223 = x_269; +x_224 = x_129; +goto block_252; +} +} +block_252: +{ +lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; uint8_t x_229; +x_225 = lean_ctor_get(x_223, 1); +lean_inc(x_225); +if (lean_is_exclusive(x_223)) { + lean_ctor_release(x_223, 0); + lean_ctor_release(x_223, 1); + x_226 = x_223; +} else { + lean_dec_ref(x_223); + x_226 = lean_box(0); +} +x_227 = lean_array_get_size(x_126); +x_228 = lean_unsigned_to_nat(0u); +x_229 = lean_nat_dec_lt(x_228, x_227); +if (x_229 == 0) +{ +uint8_t x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; +lean_dec(x_227); +lean_dec(x_126); +lean_dec(x_9); +x_230 = 1; +x_231 = lean_box(x_230); +if (lean_is_scalar(x_226)) { + x_232 = lean_alloc_ctor(0, 2, 0); +} else { + x_232 = x_226; +} +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_225); +if (lean_is_scalar(x_130)) { + x_233 = lean_alloc_ctor(0, 2, 0); +} else { + x_233 = x_130; +} +lean_ctor_set(x_233, 0, x_232); +lean_ctor_set(x_233, 1, x_224); +return x_233; +} +else +{ +uint8_t x_234; +x_234 = lean_nat_dec_le(x_227, x_227); +if (x_234 == 0) +{ +uint8_t x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; +lean_dec(x_227); +lean_dec(x_126); +lean_dec(x_9); +x_235 = 1; +x_236 = lean_box(x_235); +if (lean_is_scalar(x_226)) { + x_237 = lean_alloc_ctor(0, 2, 0); +} else { + x_237 = x_226; +} +lean_ctor_set(x_237, 0, x_236); +lean_ctor_set(x_237, 1, x_225); +if (lean_is_scalar(x_130)) { + x_238 = lean_alloc_ctor(0, 2, 0); +} else { + x_238 = x_130; +} +lean_ctor_set(x_238, 0, x_237); +lean_ctor_set(x_238, 1, x_224); +return x_238; +} +else +{ +size_t x_239; size_t x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; uint8_t x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; +lean_dec(x_226); +lean_dec(x_130); +x_239 = 0; +x_240 = lean_usize_of_nat(x_227); +lean_dec(x_227); +x_241 = lean_box(0); +x_242 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_126, x_239, x_240, x_241, x_9, x_225, x_224); +lean_dec(x_9); +lean_dec(x_126); +x_243 = lean_ctor_get(x_242, 0); +lean_inc(x_243); +x_244 = lean_ctor_get(x_242, 1); +lean_inc(x_244); +if (lean_is_exclusive(x_242)) { + lean_ctor_release(x_242, 0); + lean_ctor_release(x_242, 1); + x_245 = x_242; +} else { + lean_dec_ref(x_242); + x_245 = lean_box(0); +} +x_246 = lean_ctor_get(x_243, 1); +lean_inc(x_246); +if (lean_is_exclusive(x_243)) { + lean_ctor_release(x_243, 0); + lean_ctor_release(x_243, 1); + x_247 = x_243; +} else { + lean_dec_ref(x_243); + x_247 = lean_box(0); +} +x_248 = 1; +x_249 = lean_box(x_248); +if (lean_is_scalar(x_247)) { + x_250 = lean_alloc_ctor(0, 2, 0); +} else { + x_250 = x_247; +} +lean_ctor_set(x_250, 0, x_249); +lean_ctor_set(x_250, 1, x_246); +if (lean_is_scalar(x_245)) { + x_251 = lean_alloc_ctor(0, 2, 0); +} else { + x_251 = x_245; +} +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_244); +return x_251; +} +} +} +} +} +else +{ +lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_312; +x_270 = lean_ctor_get(x_16, 0); +lean_inc(x_270); +lean_dec(x_16); +x_271 = lean_ctor_get(x_14, 1); +lean_inc(x_271); +lean_dec(x_14); +x_272 = lean_ctor_get(x_270, 0); +lean_inc(x_272); +x_273 = lean_ctor_get(x_270, 1); +lean_inc(x_273); +lean_dec(x_270); +x_274 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_274, 0, x_272); +lean_inc(x_5); +x_275 = l_Lake_checkHashUpToDate___at_Lake_buildFileUnlessUpToDate___spec__4(x_4, x_5, x_274, x_8, x_9, x_271, x_15); +x_276 = lean_ctor_get(x_275, 0); +lean_inc(x_276); +x_277 = lean_ctor_get(x_275, 1); +lean_inc(x_277); +if (lean_is_exclusive(x_275)) { + lean_ctor_release(x_275, 0); + lean_ctor_release(x_275, 1); + x_278 = x_275; +} else { + lean_dec_ref(x_275); + x_278 = lean_box(0); +} +x_279 = lean_ctor_get(x_276, 0); +lean_inc(x_279); +x_280 = lean_ctor_get(x_276, 1); +lean_inc(x_280); +if (lean_is_exclusive(x_276)) { + lean_ctor_release(x_276, 0); + lean_ctor_release(x_276, 1); + x_281 = x_276; +} else { + lean_dec_ref(x_276); + x_281 = lean_box(0); +} +x_312 = lean_unbox(x_279); +lean_dec(x_279); +if (x_312 == 0) +{ +lean_object* x_313; lean_object* x_314; +lean_dec(x_281); +lean_dec(x_278); +lean_dec(x_273); +x_313 = lean_box(0); +x_314 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_12, x_13, x_6, x_5, x_7, x_313, x_9, x_280, x_277); +return x_314; +} +else +{ +lean_object* x_315; uint8_t x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; lean_object* x_320; lean_object* x_321; uint8_t x_322; +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_6); +lean_dec(x_5); +x_315 = lean_ctor_get(x_280, 0); +lean_inc(x_315); +x_316 = lean_ctor_get_uint8(x_280, sizeof(void*)*1); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + x_317 = x_280; +} else { + lean_dec_ref(x_280); + x_317 = lean_box(0); +} +x_318 = l_Lake_instOrdJobAction; +x_319 = 1; +x_320 = lean_box(x_316); +x_321 = lean_box(x_319); +x_322 = l_instDecidableRelLe___rarg(x_318, x_320, x_321); +if (x_322 == 0) +{ +lean_object* x_323; lean_object* x_324; lean_object* x_325; +if (lean_is_scalar(x_317)) { + x_323 = lean_alloc_ctor(0, 1, 1); +} else { + x_323 = x_317; +} +lean_ctor_set(x_323, 0, x_315); +lean_ctor_set_uint8(x_323, sizeof(void*)*1, x_316); +x_324 = lean_box(0); +if (lean_is_scalar(x_281)) { + x_325 = lean_alloc_ctor(0, 2, 0); +} else { + x_325 = x_281; +} +lean_ctor_set(x_325, 0, x_324); +lean_ctor_set(x_325, 1, x_323); +x_282 = x_325; +x_283 = x_277; +goto block_311; +} +else +{ +lean_object* x_326; lean_object* x_327; lean_object* x_328; +if (lean_is_scalar(x_317)) { + x_326 = lean_alloc_ctor(0, 1, 1); +} else { + x_326 = x_317; +} +lean_ctor_set(x_326, 0, x_315); +lean_ctor_set_uint8(x_326, sizeof(void*)*1, x_319); +x_327 = lean_box(0); +if (lean_is_scalar(x_281)) { + x_328 = lean_alloc_ctor(0, 2, 0); +} else { + x_328 = x_281; +} +lean_ctor_set(x_328, 0, x_327); +lean_ctor_set(x_328, 1, x_326); +x_282 = x_328; +x_283 = x_277; +goto block_311; +} +} +block_311: +{ +lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; uint8_t x_288; +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 = lean_array_get_size(x_273); +x_287 = lean_unsigned_to_nat(0u); +x_288 = lean_nat_dec_lt(x_287, x_286); +if (x_288 == 0) +{ +uint8_t x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; +lean_dec(x_286); +lean_dec(x_273); +lean_dec(x_9); +x_289 = 1; +x_290 = lean_box(x_289); +if (lean_is_scalar(x_285)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_285; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_284); +if (lean_is_scalar(x_278)) { + x_292 = lean_alloc_ctor(0, 2, 0); +} else { + x_292 = x_278; +} +lean_ctor_set(x_292, 0, x_291); +lean_ctor_set(x_292, 1, x_283); +return x_292; +} +else +{ +uint8_t x_293; +x_293 = lean_nat_dec_le(x_286, x_286); +if (x_293 == 0) +{ +uint8_t x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; +lean_dec(x_286); +lean_dec(x_273); +lean_dec(x_9); +x_294 = 1; +x_295 = lean_box(x_294); +if (lean_is_scalar(x_285)) { + x_296 = lean_alloc_ctor(0, 2, 0); +} else { + x_296 = x_285; +} +lean_ctor_set(x_296, 0, x_295); +lean_ctor_set(x_296, 1, x_284); +if (lean_is_scalar(x_278)) { + x_297 = lean_alloc_ctor(0, 2, 0); +} else { + x_297 = x_278; +} +lean_ctor_set(x_297, 0, x_296); +lean_ctor_set(x_297, 1, x_283); +return x_297; +} +else +{ +size_t x_298; size_t x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; uint8_t x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_285); +lean_dec(x_278); +x_298 = 0; +x_299 = lean_usize_of_nat(x_286); +lean_dec(x_286); +x_300 = lean_box(0); +x_301 = l_Array_foldlMUnsafe_fold___at_Lake_buildFileUnlessUpToDate___spec__6(x_273, x_298, x_299, x_300, x_9, x_284, x_283); +lean_dec(x_9); +lean_dec(x_273); +x_302 = lean_ctor_get(x_301, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_301, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_301)) { + lean_ctor_release(x_301, 0); + lean_ctor_release(x_301, 1); + x_304 = x_301; +} else { + lean_dec_ref(x_301); + x_304 = lean_box(0); +} +x_305 = lean_ctor_get(x_302, 1); +lean_inc(x_305); +if (lean_is_exclusive(x_302)) { + lean_ctor_release(x_302, 0); + lean_ctor_release(x_302, 1); + x_306 = x_302; +} else { + lean_dec_ref(x_302); + x_306 = lean_box(0); +} +x_307 = 1; +x_308 = lean_box(x_307); +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); +if (lean_is_scalar(x_304)) { + x_310 = lean_alloc_ctor(0, 2, 0); +} else { + x_310 = x_304; +} +lean_ctor_set(x_310, 0, x_309); +lean_ctor_set(x_310, 1, x_303); +return x_310; +} +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_fetchOptRelease___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_fetchOptRelease___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_fetchOptRelease___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_fetchOptRelease___spec__2(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_fetchOptRelease___spec__3), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_Package_fetchOptRelease___spec__4(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_fetchOptRelease___spec__5), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_fetchOptRelease___spec__3), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_Package_fetchOptRelease___spec__4(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_fetchOptRelease___spec__3), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_Package_fetchOptRelease___spec__4(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_fetchOptRelease___spec__5), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_fetchOptRelease___spec__3), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_Package_fetchOptRelease___spec__4(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_6 = l_Lake_Git_defaultRemote; +x_7 = l_Lake_GitRepo_getFilteredRemoteUrl_x3f(x_6, x_1, x_4); +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_3); +lean_ctor_set(x_7, 0, x_10); +return x_7; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get(x_7, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_7); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_3); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +return x_14; +} +} +else +{ +lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_15 = lean_ctor_get(x_3, 0); +x_16 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +lean_inc(x_15); +lean_dec(x_3); +x_17 = l_Lake_Git_defaultRemote; +x_18 = l_Lake_GitRepo_getFilteredRemoteUrl_x3f(x_17, x_1, x_4); +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_18, 1); +lean_inc(x_20); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + lean_ctor_release(x_18, 1); + x_21 = x_18; +} else { + lean_dec_ref(x_18); + x_21 = lean_box(0); +} +x_22 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_22, 0, x_15); +lean_ctor_set_uint8(x_22, sizeof(void*)*1, x_16); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_19); +lean_ctor_set(x_23, 1, x_22); +if (lean_is_scalar(x_21)) { + x_24 = lean_alloc_ctor(0, 2, 0); +} else { + x_24 = x_21; +} +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_20); +return x_24; +} +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__2___closed__1() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = 1; +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_box(x_1); +x_4 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_4, 0, x_3); +lean_ctor_set(x_4, 1, x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = l_Lake_Package_fetchOptRelease___lambda__2___closed__1; +x_6 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_3); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_4); +return x_7; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(4u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("describe", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_fetchOptRelease___lambda__3___closed__1; +x_2 = l_Lake_Package_fetchOptRelease___lambda__3___closed__2; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("--tags", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_fetchOptRelease___lambda__3___closed__3; +x_2 = l_Lake_Package_fetchOptRelease___lambda__3___closed__4; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("--exact-match", 13); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_fetchOptRelease___lambda__3___closed__5; +x_2 = l_Lake_Package_fetchOptRelease___lambda__3___closed__6; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("HEAD", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_fetchOptRelease___lambda__3___closed__7; +x_2 = l_Lake_Package_fetchOptRelease___lambda__3___closed__8; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__10() { +_start: +{ +uint8_t x_1; lean_object* x_2; +x_1 = 1; +x_2 = lean_alloc_ctor(0, 0, 3); +lean_ctor_set_uint8(x_2, 0, x_1); +lean_ctor_set_uint8(x_2, 1, x_1); +lean_ctor_set_uint8(x_2, 2, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__11() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("git", 3); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__12() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": wanted prebuilt release, but no tag found for revision", 56); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__13() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = 0; +x_2 = l_Lake_BuildTrace_nil; +x_3 = lean_box(x_1); +x_4 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_4, 0, x_3); +lean_ctor_set(x_4, 1, x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__14() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("/releases/download/", 19); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__15() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("/", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__16() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(".trace", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__18() { +_start: +{ +uint32_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 0; +x_2 = l_Lake_Package_fetchOptRelease___lambda__3___closed__17; +x_3 = lean_alloc_ctor(0, 1, 4); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint32(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__19() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("downloading ", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__20() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_fetchOptRelease___lambda__2___boxed), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__21() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unpacking ", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__22() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__23() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": wanted prebuilt release, but repository URL not known; the package may need to set 'releaseRepo'", 98); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +if (lean_obj_tag(x_4) == 0) +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_477; uint8_t x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; uint8_t x_484; lean_object* x_485; uint8_t x_486; +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_477 = lean_ctor_get(x_3, 2); +lean_inc(x_477); +lean_dec(x_3); +x_478 = 1; +x_479 = l_Lean_Name_toString(x_477, x_478); +x_480 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_481 = lean_string_append(x_480, x_479); +lean_dec(x_479); +x_482 = l_Lake_Package_fetchOptRelease___lambda__3___closed__23; +x_483 = lean_string_append(x_481, x_482); +x_484 = 1; +x_485 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_485, 0, x_483); +lean_ctor_set_uint8(x_485, sizeof(void*)*1, x_484); +x_486 = !lean_is_exclusive(x_7); +if (x_486 == 0) +{ +lean_object* x_487; uint8_t x_488; lean_object* x_489; lean_object* x_490; uint8_t x_491; lean_object* x_492; lean_object* x_493; uint8_t x_494; +x_487 = lean_ctor_get(x_7, 0); +x_488 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +x_489 = lean_array_push(x_487, x_485); +x_490 = l_Lake_instOrdJobAction; +x_491 = 2; +x_492 = lean_box(x_488); +x_493 = lean_box(x_491); +x_494 = l_instDecidableRelLe___rarg(x_490, x_492, x_493); +if (x_494 == 0) +{ +lean_object* x_495; lean_object* x_496; lean_object* x_497; +lean_ctor_set(x_7, 0, x_489); +x_495 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_496 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_496, 0, x_495); +lean_ctor_set(x_496, 1, x_7); +x_497 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_497, 0, x_496); +lean_ctor_set(x_497, 1, x_8); +return x_497; +} +else +{ +lean_object* x_498; lean_object* x_499; lean_object* x_500; +lean_ctor_set(x_7, 0, x_489); +lean_ctor_set_uint8(x_7, sizeof(void*)*1, x_491); +x_498 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_499 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_499, 0, x_498); +lean_ctor_set(x_499, 1, x_7); +x_500 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_500, 0, x_499); +lean_ctor_set(x_500, 1, x_8); +return x_500; +} +} +else +{ +lean_object* x_501; uint8_t x_502; lean_object* x_503; lean_object* x_504; uint8_t x_505; lean_object* x_506; lean_object* x_507; uint8_t x_508; +x_501 = lean_ctor_get(x_7, 0); +x_502 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_501); +lean_dec(x_7); +x_503 = lean_array_push(x_501, x_485); +x_504 = l_Lake_instOrdJobAction; +x_505 = 2; +x_506 = lean_box(x_502); +x_507 = lean_box(x_505); +x_508 = l_instDecidableRelLe___rarg(x_504, x_506, x_507); +if (x_508 == 0) +{ +lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; +x_509 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_509, 0, x_503); +lean_ctor_set_uint8(x_509, sizeof(void*)*1, x_502); +x_510 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_511 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_511, 0, x_510); +lean_ctor_set(x_511, 1, x_509); +x_512 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_512, 0, x_511); +lean_ctor_set(x_512, 1, x_8); +return x_512; +} +else +{ +lean_object* x_513; lean_object* x_514; lean_object* x_515; lean_object* x_516; +x_513 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_513, 0, x_503); +lean_ctor_set_uint8(x_513, sizeof(void*)*1, x_505); +x_514 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_515 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_515, 0, x_514); +lean_ctor_set(x_515, 1, x_513); +x_516 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_516, 0, x_515); +lean_ctor_set(x_516, 1, x_8); +return x_516; +} +} +} +else +{ +lean_object* x_517; +x_517 = lean_ctor_get(x_5, 0); +x_9 = x_517; +goto block_476; +} +} +else +{ +lean_object* x_518; +x_518 = lean_ctor_get(x_4, 0); +x_9 = x_518; +goto block_476; +} +block_476: +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_7); +if (x_10 == 0) +{ +lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_1); +x_13 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_13, 0, x_1); +x_14 = l_Lake_Package_fetchOptRelease___lambda__3___closed__10; +x_15 = l_Lake_Package_fetchOptRelease___lambda__3___closed__11; +x_16 = l_Lake_Package_fetchOptRelease___lambda__3___closed__9; +x_17 = 0; +x_18 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_18, 0, x_14); +lean_ctor_set(x_18, 1, x_15); +lean_ctor_set(x_18, 2, x_16); +lean_ctor_set(x_18, 3, x_13); +lean_ctor_set(x_18, 4, x_2); +lean_ctor_set_uint8(x_18, sizeof(void*)*5, x_17); +x_19 = l_Lake_captureProc_x3f(x_18, x_8); +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +if (lean_obj_tag(x_20) == 0) +{ +uint8_t x_21; +lean_dec(x_6); +lean_dec(x_1); +x_21 = !lean_is_exclusive(x_19); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_22 = lean_ctor_get(x_19, 0); +lean_dec(x_22); +x_23 = lean_ctor_get(x_3, 2); +lean_inc(x_23); +lean_dec(x_3); +x_24 = 1; +x_25 = l_Lean_Name_toString(x_23, x_24); +x_26 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_27 = lean_string_append(x_26, x_25); +lean_dec(x_25); +x_28 = l_Lake_Package_fetchOptRelease___lambda__3___closed__12; +x_29 = lean_string_append(x_27, x_28); +x_30 = 1; +x_31 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set_uint8(x_31, sizeof(void*)*1, x_30); +x_32 = lean_array_push(x_11, x_31); +x_33 = l_Lake_instOrdJobAction; +x_34 = 2; +x_35 = lean_box(x_12); +x_36 = lean_box(x_34); +x_37 = l_instDecidableRelLe___rarg(x_33, x_35, x_36); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +lean_ctor_set(x_7, 0, x_32); +x_38 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_7); +lean_ctor_set(x_19, 0, x_39); +return x_19; +} +else +{ +lean_object* x_40; lean_object* x_41; +lean_ctor_set(x_7, 0, x_32); +lean_ctor_set_uint8(x_7, sizeof(void*)*1, x_34); +x_40 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_7); +lean_ctor_set(x_19, 0, x_41); +return x_19; +} +} +else +{ +lean_object* x_42; lean_object* x_43; uint8_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; +x_42 = lean_ctor_get(x_19, 1); +lean_inc(x_42); +lean_dec(x_19); +x_43 = lean_ctor_get(x_3, 2); +lean_inc(x_43); +lean_dec(x_3); +x_44 = 1; +x_45 = l_Lean_Name_toString(x_43, x_44); +x_46 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_47 = lean_string_append(x_46, x_45); +lean_dec(x_45); +x_48 = l_Lake_Package_fetchOptRelease___lambda__3___closed__12; +x_49 = lean_string_append(x_47, x_48); +x_50 = 1; +x_51 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set_uint8(x_51, sizeof(void*)*1, x_50); +x_52 = lean_array_push(x_11, x_51); +x_53 = l_Lake_instOrdJobAction; +x_54 = 2; +x_55 = lean_box(x_12); +x_56 = lean_box(x_54); +x_57 = l_instDecidableRelLe___rarg(x_53, x_55, x_56); +if (x_57 == 0) +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_ctor_set(x_7, 0, x_52); +x_58 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_7); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_42); +return x_60; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +lean_ctor_set(x_7, 0, x_52); +lean_ctor_set_uint8(x_7, sizeof(void*)*1, x_54); +x_61 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_7); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_42); +return x_63; +} +} +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint64_t x_76; uint64_t x_77; uint64_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; uint8_t x_92; lean_object* x_93; +x_64 = lean_ctor_get(x_19, 1); +lean_inc(x_64); +lean_dec(x_19); +x_65 = lean_ctor_get(x_20, 0); +lean_inc(x_65); +lean_dec(x_20); +x_66 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_67 = lean_string_append(x_66, x_9); +x_68 = l_Lake_Package_fetchOptRelease___lambda__3___closed__14; +x_69 = lean_string_append(x_67, x_68); +x_70 = lean_string_append(x_69, x_65); +x_71 = l_Lake_Package_fetchOptRelease___lambda__3___closed__15; +x_72 = lean_string_append(x_70, x_71); +x_73 = lean_ctor_get(x_3, 16); +lean_inc(x_73); +x_74 = lean_string_append(x_72, x_73); +x_75 = lean_string_append(x_74, x_66); +x_76 = lean_string_hash(x_75); +x_77 = 1723; +x_78 = lean_uint64_mix_hash(x_77, x_76); +x_79 = l_Lake_defaultLakeDir; +lean_inc(x_1); +x_80 = l_System_FilePath_join(x_1, x_79); +lean_inc(x_73); +x_81 = l_System_FilePath_join(x_80, x_73); +x_82 = l_Lake_Package_fetchOptRelease___lambda__3___closed__16; +lean_inc(x_81); +x_83 = lean_string_append(x_81, x_82); +x_84 = l_Lake_Package_fetchOptRelease___lambda__3___closed__18; +x_85 = lean_box_uint64(x_78); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_84); +x_87 = l_Lake_Package_fetchOptRelease___lambda__3___closed__19; +x_88 = lean_string_append(x_87, x_75); +x_89 = lean_string_append(x_88, x_66); +x_90 = 0; +x_91 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set_uint8(x_91, sizeof(void*)*1, x_90); +x_92 = 2; +lean_inc(x_6); +lean_inc(x_81); +x_93 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1(x_75, x_81, x_91, x_81, x_86, x_83, x_92, x_84, x_6, x_7, x_64); +if (lean_obj_tag(x_93) == 0) +{ +lean_object* x_94; +x_94 = lean_ctor_get(x_93, 0); +lean_inc(x_94); +if (lean_obj_tag(x_94) == 0) +{ +lean_object* x_95; uint8_t x_96; +x_95 = lean_ctor_get(x_93, 1); +lean_inc(x_95); +lean_dec(x_93); +x_96 = !lean_is_exclusive(x_94); +if (x_96 == 0) +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; +x_97 = lean_ctor_get(x_94, 0); +x_98 = lean_ctor_get(x_94, 1); +x_99 = lean_ctor_get(x_3, 8); +lean_inc(x_99); +x_100 = l_System_FilePath_join(x_1, x_99); +x_101 = !lean_is_exclusive(x_98); +if (x_101 == 0) +{ +lean_object* x_102; uint8_t 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; uint8_t x_164; +x_102 = lean_ctor_get(x_98, 0); +x_103 = lean_ctor_get_uint8(x_98, sizeof(void*)*1); +x_104 = l_System_FilePath_pathExists(x_100, x_95); +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); +lean_inc(x_102); +x_107 = l_Lake_Package_fetchOptRelease___lambda__3___closed__20; +x_164 = lean_unbox(x_97); +lean_dec(x_97); +if (x_164 == 0) +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; uint8_t x_168; +lean_dec(x_105); +x_165 = l_Lake_instOrdJobAction; +x_166 = lean_box(x_103); +x_167 = lean_box(x_92); +x_168 = l_instDecidableRelLe___rarg(x_165, x_166, x_167); +if (x_168 == 0) +{ +lean_object* x_169; +lean_dec(x_102); +x_169 = lean_box(0); +lean_ctor_set(x_94, 0, x_169); +x_108 = x_94; +x_109 = x_106; +goto block_163; +} +else +{ +lean_object* x_170; lean_object* x_171; +lean_dec(x_98); +x_170 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_170, 0, x_102); +lean_ctor_set_uint8(x_170, sizeof(void*)*1, x_92); +x_171 = lean_box(0); +lean_ctor_set(x_94, 1, x_170); +lean_ctor_set(x_94, 0, x_171); +x_108 = x_94; +x_109 = x_106; +goto block_163; +} +} +else +{ +uint8_t x_172; +x_172 = lean_unbox(x_105); +lean_dec(x_105); +if (x_172 == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; uint8_t x_176; +x_173 = l_Lake_instOrdJobAction; +x_174 = lean_box(x_103); +x_175 = lean_box(x_92); +x_176 = l_instDecidableRelLe___rarg(x_173, x_174, x_175); +if (x_176 == 0) +{ +lean_object* x_177; +lean_dec(x_102); +x_177 = lean_box(0); +lean_ctor_set(x_94, 0, x_177); +x_108 = x_94; +x_109 = x_106; +goto block_163; +} +else +{ +lean_object* x_178; lean_object* x_179; +lean_dec(x_98); +x_178 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_178, 0, x_102); +lean_ctor_set_uint8(x_178, sizeof(void*)*1, x_92); +x_179 = lean_box(0); +lean_ctor_set(x_94, 1, x_178); +lean_ctor_set(x_94, 0, x_179); +x_108 = x_94; +x_109 = x_106; +goto block_163; +} +} +else +{ +lean_object* x_180; lean_object* x_181; +lean_dec(x_102); +lean_dec(x_100); +lean_free_object(x_94); +lean_dec(x_81); +lean_dec(x_73); +lean_dec(x_65); +lean_dec(x_3); +x_180 = lean_box(0); +x_181 = lean_apply_4(x_107, x_180, x_6, x_98, x_106); +return x_181; +} +} +block_163: +{ +lean_object* x_110; lean_object* x_111; uint8_t 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; uint8_t x_123; +x_110 = lean_ctor_get(x_108, 1); +lean_inc(x_110); +lean_dec(x_108); +x_111 = lean_ctor_get(x_3, 2); +lean_inc(x_111); +lean_dec(x_3); +x_112 = 1; +x_113 = l_Lean_Name_toString(x_111, x_112); +x_114 = l_Lake_Package_fetchOptRelease___lambda__3___closed__21; +x_115 = lean_string_append(x_114, x_113); +lean_dec(x_113); +x_116 = l_Lake_Package_fetchOptRelease___lambda__3___closed__22; +x_117 = lean_string_append(x_115, x_116); +x_118 = lean_string_append(x_117, x_65); +lean_dec(x_65); +x_119 = lean_string_append(x_118, x_116); +x_120 = lean_string_append(x_119, x_73); +lean_dec(x_73); +x_121 = lean_string_append(x_120, x_66); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_121); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_90); +x_123 = !lean_is_exclusive(x_110); +if (x_123 == 0) +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +x_124 = lean_ctor_get(x_110, 0); +x_125 = lean_array_push(x_124, x_122); +x_126 = l_Lake_untar(x_81, x_100, x_112, x_125, x_109); +x_127 = lean_ctor_get(x_126, 0); +lean_inc(x_127); +if (lean_obj_tag(x_127) == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; +x_128 = lean_ctor_get(x_126, 1); +lean_inc(x_128); +lean_dec(x_126); +x_129 = lean_ctor_get(x_127, 0); +lean_inc(x_129); +x_130 = lean_ctor_get(x_127, 1); +lean_inc(x_130); +lean_dec(x_127); +lean_ctor_set(x_110, 0, x_130); +x_131 = lean_apply_4(x_107, x_129, x_6, x_110, x_128); +return x_131; +} +else +{ +uint8_t x_132; +lean_dec(x_6); +x_132 = !lean_is_exclusive(x_126); +if (x_132 == 0) +{ +lean_object* x_133; uint8_t x_134; +x_133 = lean_ctor_get(x_126, 0); +lean_dec(x_133); +x_134 = !lean_is_exclusive(x_127); +if (x_134 == 0) +{ +lean_object* x_135; +x_135 = lean_ctor_get(x_127, 1); +lean_ctor_set(x_110, 0, x_135); +lean_ctor_set(x_127, 1, x_110); +return x_126; +} +else +{ +lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_136 = lean_ctor_get(x_127, 0); +x_137 = lean_ctor_get(x_127, 1); +lean_inc(x_137); +lean_inc(x_136); +lean_dec(x_127); +lean_ctor_set(x_110, 0, x_137); +x_138 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_138, 0, x_136); +lean_ctor_set(x_138, 1, x_110); +lean_ctor_set(x_126, 0, x_138); +return x_126; +} +} +else +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; +x_139 = lean_ctor_get(x_126, 1); +lean_inc(x_139); +lean_dec(x_126); +x_140 = lean_ctor_get(x_127, 0); +lean_inc(x_140); +x_141 = lean_ctor_get(x_127, 1); +lean_inc(x_141); +if (lean_is_exclusive(x_127)) { + lean_ctor_release(x_127, 0); + lean_ctor_release(x_127, 1); + x_142 = x_127; +} else { + lean_dec_ref(x_127); + x_142 = lean_box(0); +} +lean_ctor_set(x_110, 0, x_141); +if (lean_is_scalar(x_142)) { + x_143 = lean_alloc_ctor(1, 2, 0); +} else { + x_143 = x_142; +} +lean_ctor_set(x_143, 0, x_140); +lean_ctor_set(x_143, 1, x_110); +x_144 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_144, 0, x_143); +lean_ctor_set(x_144, 1, x_139); +return x_144; +} +} +} +else +{ +lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; +x_145 = lean_ctor_get(x_110, 0); +x_146 = lean_ctor_get_uint8(x_110, sizeof(void*)*1); +lean_inc(x_145); +lean_dec(x_110); +x_147 = lean_array_push(x_145, x_122); +x_148 = l_Lake_untar(x_81, x_100, x_112, x_147, x_109); +x_149 = lean_ctor_get(x_148, 0); +lean_inc(x_149); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_150 = lean_ctor_get(x_148, 1); +lean_inc(x_150); +lean_dec(x_148); +x_151 = lean_ctor_get(x_149, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_149, 1); +lean_inc(x_152); +lean_dec(x_149); +x_153 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_153, 0, x_152); +lean_ctor_set_uint8(x_153, sizeof(void*)*1, x_146); +x_154 = lean_apply_4(x_107, x_151, x_6, x_153, x_150); +return x_154; +} +else +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; +lean_dec(x_6); +x_155 = lean_ctor_get(x_148, 1); +lean_inc(x_155); +if (lean_is_exclusive(x_148)) { + lean_ctor_release(x_148, 0); + lean_ctor_release(x_148, 1); + x_156 = x_148; +} else { + lean_dec_ref(x_148); + x_156 = lean_box(0); +} +x_157 = lean_ctor_get(x_149, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_149, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_159 = x_149; +} else { + lean_dec_ref(x_149); + x_159 = lean_box(0); +} +x_160 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_160, 0, x_158); +lean_ctor_set_uint8(x_160, sizeof(void*)*1, x_146); +if (lean_is_scalar(x_159)) { + x_161 = lean_alloc_ctor(1, 2, 0); +} else { + x_161 = x_159; +} +lean_ctor_set(x_161, 0, x_157); +lean_ctor_set(x_161, 1, x_160); +if (lean_is_scalar(x_156)) { + x_162 = lean_alloc_ctor(0, 2, 0); +} else { + x_162 = x_156; +} +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_155); +return x_162; +} +} +} +} +else +{ +lean_object* x_182; uint8_t x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_224; +x_182 = lean_ctor_get(x_98, 0); +x_183 = lean_ctor_get_uint8(x_98, sizeof(void*)*1); +lean_inc(x_182); +lean_dec(x_98); +x_184 = l_System_FilePath_pathExists(x_100, x_95); +x_185 = lean_ctor_get(x_184, 0); +lean_inc(x_185); +x_186 = lean_ctor_get(x_184, 1); +lean_inc(x_186); +lean_dec(x_184); +lean_inc(x_182); +x_187 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_187, 0, x_182); +lean_ctor_set_uint8(x_187, sizeof(void*)*1, x_183); +x_188 = l_Lake_Package_fetchOptRelease___lambda__3___closed__20; +x_224 = lean_unbox(x_97); +lean_dec(x_97); +if (x_224 == 0) +{ +lean_object* x_225; lean_object* x_226; lean_object* x_227; uint8_t x_228; +lean_dec(x_185); +x_225 = l_Lake_instOrdJobAction; +x_226 = lean_box(x_183); +x_227 = lean_box(x_92); +x_228 = l_instDecidableRelLe___rarg(x_225, x_226, x_227); +if (x_228 == 0) +{ +lean_object* x_229; +lean_dec(x_182); +x_229 = lean_box(0); +lean_ctor_set(x_94, 1, x_187); +lean_ctor_set(x_94, 0, x_229); +x_189 = x_94; +x_190 = x_186; +goto block_223; +} +else +{ +lean_object* x_230; lean_object* x_231; +lean_dec(x_187); +x_230 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_230, 0, x_182); +lean_ctor_set_uint8(x_230, sizeof(void*)*1, x_92); +x_231 = lean_box(0); +lean_ctor_set(x_94, 1, x_230); +lean_ctor_set(x_94, 0, x_231); +x_189 = x_94; +x_190 = x_186; +goto block_223; +} +} +else +{ +uint8_t x_232; +x_232 = lean_unbox(x_185); +lean_dec(x_185); +if (x_232 == 0) +{ +lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; +x_233 = l_Lake_instOrdJobAction; +x_234 = lean_box(x_183); +x_235 = lean_box(x_92); +x_236 = l_instDecidableRelLe___rarg(x_233, x_234, x_235); +if (x_236 == 0) +{ +lean_object* x_237; +lean_dec(x_182); +x_237 = lean_box(0); +lean_ctor_set(x_94, 1, x_187); +lean_ctor_set(x_94, 0, x_237); +x_189 = x_94; +x_190 = x_186; +goto block_223; +} +else +{ +lean_object* x_238; lean_object* x_239; +lean_dec(x_187); +x_238 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_238, 0, x_182); +lean_ctor_set_uint8(x_238, sizeof(void*)*1, x_92); +x_239 = lean_box(0); +lean_ctor_set(x_94, 1, x_238); +lean_ctor_set(x_94, 0, x_239); +x_189 = x_94; +x_190 = x_186; +goto block_223; +} +} +else +{ +lean_object* x_240; lean_object* x_241; +lean_dec(x_182); +lean_dec(x_100); +lean_free_object(x_94); +lean_dec(x_81); +lean_dec(x_73); +lean_dec(x_65); +lean_dec(x_3); +x_240 = lean_box(0); +x_241 = lean_apply_4(x_188, x_240, x_6, x_187, x_186); +return x_241; +} +} +block_223: +{ +lean_object* x_191; lean_object* x_192; uint8_t x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; +x_191 = lean_ctor_get(x_189, 1); +lean_inc(x_191); +lean_dec(x_189); +x_192 = lean_ctor_get(x_3, 2); +lean_inc(x_192); +lean_dec(x_3); +x_193 = 1; +x_194 = l_Lean_Name_toString(x_192, x_193); +x_195 = l_Lake_Package_fetchOptRelease___lambda__3___closed__21; +x_196 = lean_string_append(x_195, x_194); +lean_dec(x_194); +x_197 = l_Lake_Package_fetchOptRelease___lambda__3___closed__22; +x_198 = lean_string_append(x_196, x_197); +x_199 = lean_string_append(x_198, x_65); +lean_dec(x_65); +x_200 = lean_string_append(x_199, x_197); +x_201 = lean_string_append(x_200, x_73); +lean_dec(x_73); +x_202 = lean_string_append(x_201, x_66); +x_203 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set_uint8(x_203, sizeof(void*)*1, x_90); +x_204 = lean_ctor_get(x_191, 0); +lean_inc(x_204); +x_205 = lean_ctor_get_uint8(x_191, sizeof(void*)*1); +if (lean_is_exclusive(x_191)) { + lean_ctor_release(x_191, 0); + x_206 = x_191; +} else { + lean_dec_ref(x_191); + x_206 = lean_box(0); +} +x_207 = lean_array_push(x_204, x_203); +x_208 = l_Lake_untar(x_81, x_100, x_193, x_207, x_190); +x_209 = lean_ctor_get(x_208, 0); +lean_inc(x_209); +if (lean_obj_tag(x_209) == 0) +{ +lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; +x_210 = lean_ctor_get(x_208, 1); +lean_inc(x_210); +lean_dec(x_208); +x_211 = lean_ctor_get(x_209, 0); +lean_inc(x_211); +x_212 = lean_ctor_get(x_209, 1); +lean_inc(x_212); +lean_dec(x_209); +if (lean_is_scalar(x_206)) { + x_213 = lean_alloc_ctor(0, 1, 1); +} else { + x_213 = x_206; +} +lean_ctor_set(x_213, 0, x_212); +lean_ctor_set_uint8(x_213, sizeof(void*)*1, x_205); +x_214 = lean_apply_4(x_188, x_211, x_6, x_213, x_210); +return x_214; +} +else +{ +lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; +lean_dec(x_6); +x_215 = lean_ctor_get(x_208, 1); +lean_inc(x_215); +if (lean_is_exclusive(x_208)) { + lean_ctor_release(x_208, 0); + lean_ctor_release(x_208, 1); + x_216 = x_208; +} else { + lean_dec_ref(x_208); + x_216 = lean_box(0); +} +x_217 = lean_ctor_get(x_209, 0); +lean_inc(x_217); +x_218 = lean_ctor_get(x_209, 1); +lean_inc(x_218); +if (lean_is_exclusive(x_209)) { + lean_ctor_release(x_209, 0); + lean_ctor_release(x_209, 1); + x_219 = x_209; +} else { + lean_dec_ref(x_209); + x_219 = lean_box(0); +} +if (lean_is_scalar(x_206)) { + x_220 = lean_alloc_ctor(0, 1, 1); +} else { + x_220 = x_206; +} +lean_ctor_set(x_220, 0, x_218); +lean_ctor_set_uint8(x_220, sizeof(void*)*1, x_205); +if (lean_is_scalar(x_219)) { + x_221 = lean_alloc_ctor(1, 2, 0); +} else { + x_221 = x_219; +} +lean_ctor_set(x_221, 0, x_217); +lean_ctor_set(x_221, 1, x_220); +if (lean_is_scalar(x_216)) { + x_222 = lean_alloc_ctor(0, 2, 0); +} else { + x_222 = x_216; +} +lean_ctor_set(x_222, 0, x_221); +lean_ctor_set(x_222, 1, x_215); +return x_222; +} +} +} +} +else +{ +lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_289; +x_242 = lean_ctor_get(x_94, 0); +x_243 = lean_ctor_get(x_94, 1); +lean_inc(x_243); +lean_inc(x_242); +lean_dec(x_94); +x_244 = lean_ctor_get(x_3, 8); +lean_inc(x_244); +x_245 = l_System_FilePath_join(x_1, x_244); +x_246 = lean_ctor_get(x_243, 0); +lean_inc(x_246); +x_247 = lean_ctor_get_uint8(x_243, sizeof(void*)*1); +if (lean_is_exclusive(x_243)) { + lean_ctor_release(x_243, 0); + x_248 = x_243; +} else { + lean_dec_ref(x_243); + x_248 = lean_box(0); +} +x_249 = l_System_FilePath_pathExists(x_245, x_95); +x_250 = lean_ctor_get(x_249, 0); +lean_inc(x_250); +x_251 = lean_ctor_get(x_249, 1); +lean_inc(x_251); +lean_dec(x_249); +lean_inc(x_246); +if (lean_is_scalar(x_248)) { + x_252 = lean_alloc_ctor(0, 1, 1); +} else { + x_252 = x_248; +} +lean_ctor_set(x_252, 0, x_246); +lean_ctor_set_uint8(x_252, sizeof(void*)*1, x_247); +x_253 = l_Lake_Package_fetchOptRelease___lambda__3___closed__20; +x_289 = lean_unbox(x_242); +lean_dec(x_242); +if (x_289 == 0) +{ +lean_object* x_290; lean_object* x_291; lean_object* x_292; uint8_t x_293; +lean_dec(x_250); +x_290 = l_Lake_instOrdJobAction; +x_291 = lean_box(x_247); +x_292 = lean_box(x_92); +x_293 = l_instDecidableRelLe___rarg(x_290, x_291, x_292); +if (x_293 == 0) +{ +lean_object* x_294; lean_object* x_295; +lean_dec(x_246); +x_294 = lean_box(0); +x_295 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_252); +x_254 = x_295; +x_255 = x_251; +goto block_288; +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; +lean_dec(x_252); +x_296 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_296, 0, x_246); +lean_ctor_set_uint8(x_296, sizeof(void*)*1, x_92); +x_297 = lean_box(0); +x_298 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_298, 0, x_297); +lean_ctor_set(x_298, 1, x_296); +x_254 = x_298; +x_255 = x_251; +goto block_288; +} +} +else +{ +uint8_t x_299; +x_299 = lean_unbox(x_250); +lean_dec(x_250); +if (x_299 == 0) +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; uint8_t x_303; +x_300 = l_Lake_instOrdJobAction; +x_301 = lean_box(x_247); +x_302 = lean_box(x_92); +x_303 = l_instDecidableRelLe___rarg(x_300, x_301, x_302); +if (x_303 == 0) +{ +lean_object* x_304; lean_object* x_305; +lean_dec(x_246); +x_304 = lean_box(0); +x_305 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_305, 0, x_304); +lean_ctor_set(x_305, 1, x_252); +x_254 = x_305; +x_255 = x_251; +goto block_288; +} +else +{ +lean_object* x_306; lean_object* x_307; lean_object* x_308; +lean_dec(x_252); +x_306 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_306, 0, x_246); +lean_ctor_set_uint8(x_306, sizeof(void*)*1, x_92); +x_307 = lean_box(0); +x_308 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_308, 0, x_307); +lean_ctor_set(x_308, 1, x_306); +x_254 = x_308; +x_255 = x_251; +goto block_288; +} +} +else +{ +lean_object* x_309; lean_object* x_310; +lean_dec(x_246); +lean_dec(x_245); +lean_dec(x_81); +lean_dec(x_73); +lean_dec(x_65); +lean_dec(x_3); +x_309 = lean_box(0); +x_310 = lean_apply_4(x_253, x_309, x_6, x_252, x_251); +return x_310; +} +} +block_288: +{ +lean_object* x_256; lean_object* x_257; uint8_t x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; +x_256 = lean_ctor_get(x_254, 1); +lean_inc(x_256); +lean_dec(x_254); +x_257 = lean_ctor_get(x_3, 2); +lean_inc(x_257); +lean_dec(x_3); +x_258 = 1; +x_259 = l_Lean_Name_toString(x_257, x_258); +x_260 = l_Lake_Package_fetchOptRelease___lambda__3___closed__21; +x_261 = lean_string_append(x_260, x_259); +lean_dec(x_259); +x_262 = l_Lake_Package_fetchOptRelease___lambda__3___closed__22; +x_263 = lean_string_append(x_261, x_262); +x_264 = lean_string_append(x_263, x_65); +lean_dec(x_65); +x_265 = lean_string_append(x_264, x_262); +x_266 = lean_string_append(x_265, x_73); +lean_dec(x_73); +x_267 = lean_string_append(x_266, x_66); +x_268 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_268, 0, x_267); +lean_ctor_set_uint8(x_268, sizeof(void*)*1, x_90); +x_269 = lean_ctor_get(x_256, 0); +lean_inc(x_269); +x_270 = lean_ctor_get_uint8(x_256, sizeof(void*)*1); +if (lean_is_exclusive(x_256)) { + lean_ctor_release(x_256, 0); + x_271 = x_256; +} else { + lean_dec_ref(x_256); + x_271 = lean_box(0); +} +x_272 = lean_array_push(x_269, x_268); +x_273 = l_Lake_untar(x_81, x_245, x_258, x_272, x_255); +x_274 = lean_ctor_get(x_273, 0); +lean_inc(x_274); +if (lean_obj_tag(x_274) == 0) +{ +lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; +x_275 = lean_ctor_get(x_273, 1); +lean_inc(x_275); +lean_dec(x_273); +x_276 = lean_ctor_get(x_274, 0); +lean_inc(x_276); +x_277 = lean_ctor_get(x_274, 1); +lean_inc(x_277); +lean_dec(x_274); +if (lean_is_scalar(x_271)) { + x_278 = lean_alloc_ctor(0, 1, 1); +} else { + x_278 = x_271; +} +lean_ctor_set(x_278, 0, x_277); +lean_ctor_set_uint8(x_278, sizeof(void*)*1, x_270); +x_279 = lean_apply_4(x_253, x_276, x_6, x_278, x_275); +return x_279; +} +else +{ +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_dec(x_6); +x_280 = lean_ctor_get(x_273, 1); +lean_inc(x_280); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + lean_ctor_release(x_273, 1); + x_281 = x_273; +} else { + lean_dec_ref(x_273); + x_281 = lean_box(0); +} +x_282 = lean_ctor_get(x_274, 0); +lean_inc(x_282); +x_283 = lean_ctor_get(x_274, 1); +lean_inc(x_283); +if (lean_is_exclusive(x_274)) { + lean_ctor_release(x_274, 0); + lean_ctor_release(x_274, 1); + x_284 = x_274; +} else { + lean_dec_ref(x_274); + x_284 = lean_box(0); +} +if (lean_is_scalar(x_271)) { + x_285 = lean_alloc_ctor(0, 1, 1); +} else { + x_285 = x_271; +} +lean_ctor_set(x_285, 0, x_283); +lean_ctor_set_uint8(x_285, sizeof(void*)*1, x_270); +if (lean_is_scalar(x_284)) { + x_286 = lean_alloc_ctor(1, 2, 0); +} else { + x_286 = x_284; +} +lean_ctor_set(x_286, 0, x_282); +lean_ctor_set(x_286, 1, x_285); +if (lean_is_scalar(x_281)) { + x_287 = lean_alloc_ctor(0, 2, 0); +} else { + x_287 = x_281; +} +lean_ctor_set(x_287, 0, x_286); +lean_ctor_set(x_287, 1, x_280); +return x_287; +} +} +} +} +else +{ +uint8_t x_311; +lean_dec(x_81); +lean_dec(x_73); +lean_dec(x_65); +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_1); +x_311 = !lean_is_exclusive(x_93); +if (x_311 == 0) +{ +lean_object* x_312; uint8_t x_313; +x_312 = lean_ctor_get(x_93, 0); +lean_dec(x_312); +x_313 = !lean_is_exclusive(x_94); +if (x_313 == 0) +{ +return x_93; +} +else +{ +lean_object* x_314; lean_object* x_315; lean_object* x_316; +x_314 = lean_ctor_get(x_94, 0); +x_315 = lean_ctor_get(x_94, 1); +lean_inc(x_315); +lean_inc(x_314); +lean_dec(x_94); +x_316 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_316, 0, x_314); +lean_ctor_set(x_316, 1, x_315); +lean_ctor_set(x_93, 0, x_316); +return x_93; +} +} +else +{ +lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; +x_317 = lean_ctor_get(x_93, 1); +lean_inc(x_317); +lean_dec(x_93); +x_318 = lean_ctor_get(x_94, 0); +lean_inc(x_318); +x_319 = lean_ctor_get(x_94, 1); +lean_inc(x_319); +if (lean_is_exclusive(x_94)) { + lean_ctor_release(x_94, 0); + lean_ctor_release(x_94, 1); + x_320 = x_94; +} else { + lean_dec_ref(x_94); + x_320 = lean_box(0); +} +if (lean_is_scalar(x_320)) { + x_321 = lean_alloc_ctor(1, 2, 0); +} else { + x_321 = x_320; +} +lean_ctor_set(x_321, 0, x_318); +lean_ctor_set(x_321, 1, x_319); +x_322 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_322, 0, x_321); +lean_ctor_set(x_322, 1, x_317); +return x_322; +} +} +} +else +{ +uint8_t x_323; +lean_dec(x_81); +lean_dec(x_73); +lean_dec(x_65); +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_1); +x_323 = !lean_is_exclusive(x_93); +if (x_323 == 0) +{ +return x_93; +} +else +{ +lean_object* x_324; lean_object* x_325; lean_object* x_326; +x_324 = lean_ctor_get(x_93, 0); +x_325 = lean_ctor_get(x_93, 1); +lean_inc(x_325); +lean_inc(x_324); +lean_dec(x_93); +x_326 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_326, 0, x_324); +lean_ctor_set(x_326, 1, x_325); +return x_326; +} +} +} +} +else +{ +lean_object* x_327; uint8_t x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; +x_327 = lean_ctor_get(x_7, 0); +x_328 = lean_ctor_get_uint8(x_7, sizeof(void*)*1); +lean_inc(x_327); +lean_dec(x_7); +lean_inc(x_1); +x_329 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_329, 0, x_1); +x_330 = l_Lake_Package_fetchOptRelease___lambda__3___closed__10; +x_331 = l_Lake_Package_fetchOptRelease___lambda__3___closed__11; +x_332 = l_Lake_Package_fetchOptRelease___lambda__3___closed__9; +x_333 = 0; +x_334 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_334, 0, x_330); +lean_ctor_set(x_334, 1, x_331); +lean_ctor_set(x_334, 2, x_332); +lean_ctor_set(x_334, 3, x_329); +lean_ctor_set(x_334, 4, x_2); +lean_ctor_set_uint8(x_334, sizeof(void*)*5, x_333); +x_335 = l_Lake_captureProc_x3f(x_334, x_8); +x_336 = lean_ctor_get(x_335, 0); +lean_inc(x_336); +if (lean_obj_tag(x_336) == 0) +{ +lean_object* x_337; lean_object* x_338; lean_object* x_339; uint8_t x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; uint8_t x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; uint8_t x_350; lean_object* x_351; lean_object* x_352; uint8_t x_353; +lean_dec(x_6); +lean_dec(x_1); +x_337 = lean_ctor_get(x_335, 1); +lean_inc(x_337); +if (lean_is_exclusive(x_335)) { + lean_ctor_release(x_335, 0); + lean_ctor_release(x_335, 1); + x_338 = x_335; +} else { + lean_dec_ref(x_335); + x_338 = lean_box(0); +} +x_339 = lean_ctor_get(x_3, 2); +lean_inc(x_339); +lean_dec(x_3); +x_340 = 1; +x_341 = l_Lean_Name_toString(x_339, x_340); +x_342 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_343 = lean_string_append(x_342, x_341); +lean_dec(x_341); +x_344 = l_Lake_Package_fetchOptRelease___lambda__3___closed__12; +x_345 = lean_string_append(x_343, x_344); +x_346 = 1; +x_347 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_347, 0, x_345); +lean_ctor_set_uint8(x_347, sizeof(void*)*1, x_346); +x_348 = lean_array_push(x_327, x_347); +x_349 = l_Lake_instOrdJobAction; +x_350 = 2; +x_351 = lean_box(x_328); +x_352 = lean_box(x_350); +x_353 = l_instDecidableRelLe___rarg(x_349, x_351, x_352); +if (x_353 == 0) +{ +lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; +x_354 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_354, 0, x_348); +lean_ctor_set_uint8(x_354, sizeof(void*)*1, x_328); +x_355 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_356 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_356, 0, x_355); +lean_ctor_set(x_356, 1, x_354); +if (lean_is_scalar(x_338)) { + x_357 = lean_alloc_ctor(0, 2, 0); +} else { + x_357 = x_338; +} +lean_ctor_set(x_357, 0, x_356); +lean_ctor_set(x_357, 1, x_337); +return x_357; +} +else +{ +lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; +x_358 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_358, 0, x_348); +lean_ctor_set_uint8(x_358, sizeof(void*)*1, x_350); +x_359 = l_Lake_Package_fetchOptRelease___lambda__3___closed__13; +x_360 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_360, 0, x_359); +lean_ctor_set(x_360, 1, x_358); +if (lean_is_scalar(x_338)) { + x_361 = lean_alloc_ctor(0, 2, 0); +} else { + x_361 = x_338; +} +lean_ctor_set(x_361, 0, x_360); +lean_ctor_set(x_361, 1, x_337); +return x_361; +} +} +else +{ +lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; uint64_t x_375; uint64_t x_376; uint64_t x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; uint8_t x_389; lean_object* x_390; uint8_t x_391; lean_object* x_392; +x_362 = lean_ctor_get(x_335, 1); +lean_inc(x_362); +lean_dec(x_335); +x_363 = lean_ctor_get(x_336, 0); +lean_inc(x_363); +lean_dec(x_336); +x_364 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_364, 0, x_327); +lean_ctor_set_uint8(x_364, sizeof(void*)*1, x_328); +x_365 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_366 = lean_string_append(x_365, x_9); +x_367 = l_Lake_Package_fetchOptRelease___lambda__3___closed__14; +x_368 = lean_string_append(x_366, x_367); +x_369 = lean_string_append(x_368, x_363); +x_370 = l_Lake_Package_fetchOptRelease___lambda__3___closed__15; +x_371 = lean_string_append(x_369, x_370); +x_372 = lean_ctor_get(x_3, 16); +lean_inc(x_372); +x_373 = lean_string_append(x_371, x_372); +x_374 = lean_string_append(x_373, x_365); +x_375 = lean_string_hash(x_374); +x_376 = 1723; +x_377 = lean_uint64_mix_hash(x_376, x_375); +x_378 = l_Lake_defaultLakeDir; +lean_inc(x_1); +x_379 = l_System_FilePath_join(x_1, x_378); +lean_inc(x_372); +x_380 = l_System_FilePath_join(x_379, x_372); +x_381 = l_Lake_Package_fetchOptRelease___lambda__3___closed__16; +lean_inc(x_380); +x_382 = lean_string_append(x_380, x_381); +x_383 = l_Lake_Package_fetchOptRelease___lambda__3___closed__18; +x_384 = lean_box_uint64(x_377); +x_385 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_385, 0, x_384); +lean_ctor_set(x_385, 1, x_383); +x_386 = l_Lake_Package_fetchOptRelease___lambda__3___closed__19; +x_387 = lean_string_append(x_386, x_374); +x_388 = lean_string_append(x_387, x_365); +x_389 = 0; +x_390 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_390, 0, x_388); +lean_ctor_set_uint8(x_390, sizeof(void*)*1, x_389); +x_391 = 2; +lean_inc(x_6); +lean_inc(x_380); +x_392 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1(x_374, x_380, x_390, x_380, x_385, x_382, x_391, x_383, x_6, x_364, x_362); +if (lean_obj_tag(x_392) == 0) +{ +lean_object* x_393; +x_393 = lean_ctor_get(x_392, 0); +lean_inc(x_393); +if (lean_obj_tag(x_393) == 0) +{ +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; uint8_t x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; uint8_t x_443; +x_394 = lean_ctor_get(x_392, 1); +lean_inc(x_394); +lean_dec(x_392); +x_395 = lean_ctor_get(x_393, 0); +lean_inc(x_395); +x_396 = lean_ctor_get(x_393, 1); +lean_inc(x_396); +if (lean_is_exclusive(x_393)) { + lean_ctor_release(x_393, 0); + lean_ctor_release(x_393, 1); + x_397 = x_393; +} else { + lean_dec_ref(x_393); + x_397 = lean_box(0); +} +x_398 = lean_ctor_get(x_3, 8); +lean_inc(x_398); +x_399 = l_System_FilePath_join(x_1, x_398); +x_400 = lean_ctor_get(x_396, 0); +lean_inc(x_400); +x_401 = lean_ctor_get_uint8(x_396, sizeof(void*)*1); +if (lean_is_exclusive(x_396)) { + lean_ctor_release(x_396, 0); + x_402 = x_396; +} else { + lean_dec_ref(x_396); + x_402 = lean_box(0); +} +x_403 = l_System_FilePath_pathExists(x_399, x_394); +x_404 = lean_ctor_get(x_403, 0); +lean_inc(x_404); +x_405 = lean_ctor_get(x_403, 1); +lean_inc(x_405); +lean_dec(x_403); +lean_inc(x_400); +if (lean_is_scalar(x_402)) { + x_406 = lean_alloc_ctor(0, 1, 1); +} else { + x_406 = x_402; +} +lean_ctor_set(x_406, 0, x_400); +lean_ctor_set_uint8(x_406, sizeof(void*)*1, x_401); +x_407 = l_Lake_Package_fetchOptRelease___lambda__3___closed__20; +x_443 = lean_unbox(x_395); +lean_dec(x_395); +if (x_443 == 0) +{ +lean_object* x_444; lean_object* x_445; lean_object* x_446; uint8_t x_447; +lean_dec(x_404); +x_444 = l_Lake_instOrdJobAction; +x_445 = lean_box(x_401); +x_446 = lean_box(x_391); +x_447 = l_instDecidableRelLe___rarg(x_444, x_445, x_446); +if (x_447 == 0) +{ +lean_object* x_448; lean_object* x_449; +lean_dec(x_400); +x_448 = lean_box(0); +if (lean_is_scalar(x_397)) { + x_449 = lean_alloc_ctor(0, 2, 0); +} else { + x_449 = x_397; +} +lean_ctor_set(x_449, 0, x_448); +lean_ctor_set(x_449, 1, x_406); +x_408 = x_449; +x_409 = x_405; +goto block_442; +} +else +{ +lean_object* x_450; lean_object* x_451; lean_object* x_452; +lean_dec(x_406); +x_450 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_450, 0, x_400); +lean_ctor_set_uint8(x_450, sizeof(void*)*1, x_391); +x_451 = lean_box(0); +if (lean_is_scalar(x_397)) { + x_452 = lean_alloc_ctor(0, 2, 0); +} else { + x_452 = x_397; +} +lean_ctor_set(x_452, 0, x_451); +lean_ctor_set(x_452, 1, x_450); +x_408 = x_452; +x_409 = x_405; +goto block_442; +} +} +else +{ +uint8_t x_453; +x_453 = lean_unbox(x_404); +lean_dec(x_404); +if (x_453 == 0) +{ +lean_object* x_454; lean_object* x_455; lean_object* x_456; uint8_t x_457; +x_454 = l_Lake_instOrdJobAction; +x_455 = lean_box(x_401); +x_456 = lean_box(x_391); +x_457 = l_instDecidableRelLe___rarg(x_454, x_455, x_456); +if (x_457 == 0) +{ +lean_object* x_458; lean_object* x_459; +lean_dec(x_400); +x_458 = lean_box(0); +if (lean_is_scalar(x_397)) { + x_459 = lean_alloc_ctor(0, 2, 0); +} else { + x_459 = x_397; +} +lean_ctor_set(x_459, 0, x_458); +lean_ctor_set(x_459, 1, x_406); +x_408 = x_459; +x_409 = x_405; +goto block_442; +} +else +{ +lean_object* x_460; lean_object* x_461; lean_object* x_462; +lean_dec(x_406); +x_460 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_460, 0, x_400); +lean_ctor_set_uint8(x_460, sizeof(void*)*1, x_391); +x_461 = lean_box(0); +if (lean_is_scalar(x_397)) { + x_462 = lean_alloc_ctor(0, 2, 0); +} else { + x_462 = x_397; +} +lean_ctor_set(x_462, 0, x_461); +lean_ctor_set(x_462, 1, x_460); +x_408 = x_462; +x_409 = x_405; +goto block_442; +} +} +else +{ +lean_object* x_463; lean_object* x_464; +lean_dec(x_400); +lean_dec(x_399); +lean_dec(x_397); +lean_dec(x_380); +lean_dec(x_372); +lean_dec(x_363); +lean_dec(x_3); +x_463 = lean_box(0); +x_464 = lean_apply_4(x_407, x_463, x_6, x_406, x_405); +return x_464; +} +} +block_442: +{ +lean_object* x_410; lean_object* x_411; uint8_t x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; lean_object* x_422; lean_object* x_423; uint8_t x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; +x_410 = lean_ctor_get(x_408, 1); +lean_inc(x_410); +lean_dec(x_408); +x_411 = lean_ctor_get(x_3, 2); +lean_inc(x_411); +lean_dec(x_3); +x_412 = 1; +x_413 = l_Lean_Name_toString(x_411, x_412); +x_414 = l_Lake_Package_fetchOptRelease___lambda__3___closed__21; +x_415 = lean_string_append(x_414, x_413); +lean_dec(x_413); +x_416 = l_Lake_Package_fetchOptRelease___lambda__3___closed__22; +x_417 = lean_string_append(x_415, x_416); +x_418 = lean_string_append(x_417, x_363); +lean_dec(x_363); +x_419 = lean_string_append(x_418, x_416); +x_420 = lean_string_append(x_419, x_372); +lean_dec(x_372); +x_421 = lean_string_append(x_420, x_365); +x_422 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_422, 0, x_421); +lean_ctor_set_uint8(x_422, sizeof(void*)*1, x_389); +x_423 = lean_ctor_get(x_410, 0); +lean_inc(x_423); +x_424 = lean_ctor_get_uint8(x_410, sizeof(void*)*1); +if (lean_is_exclusive(x_410)) { + lean_ctor_release(x_410, 0); + x_425 = x_410; +} else { + lean_dec_ref(x_410); + x_425 = lean_box(0); +} +x_426 = lean_array_push(x_423, x_422); +x_427 = l_Lake_untar(x_380, x_399, x_412, x_426, x_409); +x_428 = lean_ctor_get(x_427, 0); +lean_inc(x_428); +if (lean_obj_tag(x_428) == 0) +{ +lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; +x_429 = lean_ctor_get(x_427, 1); +lean_inc(x_429); +lean_dec(x_427); +x_430 = lean_ctor_get(x_428, 0); +lean_inc(x_430); +x_431 = lean_ctor_get(x_428, 1); +lean_inc(x_431); +lean_dec(x_428); +if (lean_is_scalar(x_425)) { + x_432 = lean_alloc_ctor(0, 1, 1); +} else { + x_432 = x_425; +} +lean_ctor_set(x_432, 0, x_431); +lean_ctor_set_uint8(x_432, sizeof(void*)*1, x_424); +x_433 = lean_apply_4(x_407, x_430, x_6, x_432, x_429); +return x_433; +} +else +{ +lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; +lean_dec(x_6); +x_434 = lean_ctor_get(x_427, 1); +lean_inc(x_434); +if (lean_is_exclusive(x_427)) { + lean_ctor_release(x_427, 0); + lean_ctor_release(x_427, 1); + x_435 = x_427; +} else { + lean_dec_ref(x_427); + x_435 = lean_box(0); +} +x_436 = lean_ctor_get(x_428, 0); +lean_inc(x_436); +x_437 = lean_ctor_get(x_428, 1); +lean_inc(x_437); +if (lean_is_exclusive(x_428)) { + lean_ctor_release(x_428, 0); + lean_ctor_release(x_428, 1); + x_438 = x_428; +} else { + lean_dec_ref(x_428); + x_438 = lean_box(0); +} +if (lean_is_scalar(x_425)) { + x_439 = lean_alloc_ctor(0, 1, 1); +} else { + x_439 = x_425; +} +lean_ctor_set(x_439, 0, x_437); +lean_ctor_set_uint8(x_439, sizeof(void*)*1, x_424); +if (lean_is_scalar(x_438)) { + x_440 = lean_alloc_ctor(1, 2, 0); +} else { + x_440 = x_438; +} +lean_ctor_set(x_440, 0, x_436); +lean_ctor_set(x_440, 1, x_439); +if (lean_is_scalar(x_435)) { + x_441 = lean_alloc_ctor(0, 2, 0); +} else { + x_441 = x_435; +} +lean_ctor_set(x_441, 0, x_440); +lean_ctor_set(x_441, 1, x_434); +return x_441; +} +} +} +else +{ +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_dec(x_380); +lean_dec(x_372); +lean_dec(x_363); +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_1); +x_465 = lean_ctor_get(x_392, 1); +lean_inc(x_465); +if (lean_is_exclusive(x_392)) { + lean_ctor_release(x_392, 0); + lean_ctor_release(x_392, 1); + x_466 = x_392; +} else { + lean_dec_ref(x_392); + x_466 = lean_box(0); +} +x_467 = lean_ctor_get(x_393, 0); +lean_inc(x_467); +x_468 = lean_ctor_get(x_393, 1); +lean_inc(x_468); +if (lean_is_exclusive(x_393)) { + lean_ctor_release(x_393, 0); + lean_ctor_release(x_393, 1); + x_469 = x_393; +} else { + lean_dec_ref(x_393); + x_469 = lean_box(0); +} +if (lean_is_scalar(x_469)) { + x_470 = lean_alloc_ctor(1, 2, 0); +} else { + x_470 = x_469; +} +lean_ctor_set(x_470, 0, x_467); +lean_ctor_set(x_470, 1, x_468); +if (lean_is_scalar(x_466)) { + x_471 = lean_alloc_ctor(0, 2, 0); +} else { + x_471 = x_466; +} +lean_ctor_set(x_471, 0, x_470); +lean_ctor_set(x_471, 1, x_465); +return x_471; +} +} +else +{ +lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; +lean_dec(x_380); +lean_dec(x_372); +lean_dec(x_363); +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_1); +x_472 = lean_ctor_get(x_392, 0); +lean_inc(x_472); +x_473 = lean_ctor_get(x_392, 1); +lean_inc(x_473); +if (lean_is_exclusive(x_392)) { + lean_ctor_release(x_392, 0); + lean_ctor_release(x_392, 1); + x_474 = x_392; +} else { + lean_dec_ref(x_392); + x_474 = lean_box(0); +} +if (lean_is_scalar(x_474)) { + x_475 = lean_alloc_ctor(1, 2, 0); +} else { + x_475 = x_474; +} +lean_ctor_set(x_475, 0, x_472); +lean_ctor_set(x_475, 1, x_473); +return x_475; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = 1; +lean_inc(x_2); +x_6 = l_IO_FS_withIsolatedStreams___at_Lake_Package_fetchOptRelease___spec__2(x_1, x_5, x_2, x_3, x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_ctor_get(x_8, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_8, 1); +lean_inc(x_12); +lean_dec(x_8); +x_13 = l_String_isEmpty(x_11); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; uint8_t x_20; +x_14 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1; +x_15 = lean_string_append(x_14, x_11); +lean_dec(x_11); +x_16 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_17 = lean_string_append(x_15, x_16); +x_18 = 1; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = !lean_is_exclusive(x_10); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_10, 0); +x_22 = lean_array_push(x_21, x_19); +lean_ctor_set(x_10, 0, x_22); +x_23 = lean_box(0); +x_24 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_12, x_23, x_2, x_10, x_9); +lean_dec(x_2); +return x_24; +} +else +{ +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 0); +x_26 = lean_ctor_get_uint8(x_10, sizeof(void*)*1); +lean_inc(x_25); +lean_dec(x_10); +x_27 = lean_array_push(x_25, x_19); +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_26); +x_29 = lean_box(0); +x_30 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_12, x_29, x_2, x_28, x_9); +lean_dec(x_2); +return x_30; +} +} +else +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_11); +x_31 = lean_box(0); +x_32 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_12, x_31, x_2, x_10, x_9); +lean_dec(x_2); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_dec(x_2); +x_33 = !lean_is_exclusive(x_6); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = lean_ctor_get(x_6, 0); +lean_dec(x_34); +x_35 = !lean_is_exclusive(x_7); +if (x_35 == 0) +{ +return x_6; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_7, 0); +x_37 = lean_ctor_get(x_7, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_7); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +lean_ctor_set(x_6, 0, x_38); +return x_6; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_39 = lean_ctor_get(x_6, 1); +lean_inc(x_39); +lean_dec(x_6); +x_40 = lean_ctor_get(x_7, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_7, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_7)) { + lean_ctor_release(x_7, 0); + lean_ctor_release(x_7, 1); + x_42 = x_7; +} else { + lean_dec_ref(x_7); + x_42 = lean_box(0); +} +if (lean_is_scalar(x_42)) { + x_43 = lean_alloc_ctor(1, 2, 0); +} else { + x_43 = x_42; +} +lean_ctor_set(x_43, 0, x_40); +lean_ctor_set(x_43, 1, x_41); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_39); +return x_44; +} +} +} +else +{ +uint8_t x_45; +lean_dec(x_2); +x_45 = !lean_is_exclusive(x_6); +if (x_45 == 0) +{ +return x_6; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_6, 0); +x_47 = lean_ctor_get(x_6, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_6); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +return x_48; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_1, 2); +lean_inc(x_9); +x_10 = lean_ctor_get(x_1, 5); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_ctor_get(x_9, 14); +lean_inc(x_11); +lean_inc(x_8); +x_12 = lean_alloc_closure((void*)(l_Lake_Package_fetchOptRelease___lambda__1___boxed), 4, 1); +lean_closure_set(x_12, 0, x_8); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_39; +x_39 = lean_ctor_get(x_9, 13); +lean_inc(x_39); +if (lean_obj_tag(x_39) == 0) +{ +x_13 = x_10; +goto block_38; +} +else +{ +uint8_t x_40; +lean_dec(x_10); +x_40 = !lean_is_exclusive(x_39); +if (x_40 == 0) +{ +x_13 = x_39; +goto block_38; +} +else +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +lean_dec(x_39); +x_42 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_42, 0, x_41); +x_13 = x_42; +goto block_38; +} +} +} +else +{ +uint8_t x_43; +lean_dec(x_10); +x_43 = !lean_is_exclusive(x_11); +if (x_43 == 0) +{ +x_13 = x_11; +goto block_38; +} +else +{ +lean_object* x_44; lean_object* x_45; +x_44 = lean_ctor_get(x_11, 0); +lean_inc(x_44); +lean_dec(x_11); +x_45 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_45, 0, x_44); +x_13 = x_45; +goto block_38; +} +} +block_38: +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_14 = l_Lake_Package_recComputeDeps___closed__1; +x_15 = lean_alloc_closure((void*)(l_Lake_Package_fetchOptRelease___lambda__3___boxed), 8, 4); +lean_closure_set(x_15, 0, x_8); +lean_closure_set(x_15, 1, x_14); +lean_closure_set(x_15, 2, x_9); +lean_closure_set(x_15, 3, x_13); +x_16 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_16, 0, x_12); +lean_closure_set(x_16, 1, x_15); +x_17 = l_Lake_Package_recBuildExtraDepTargets___closed__2; +x_18 = lean_alloc_closure((void*)(l_Lake_Package_fetchOptRelease___lambda__4), 4, 3); +lean_closure_set(x_18, 0, x_16); +lean_closure_set(x_18, 1, x_4); +lean_closure_set(x_18, 2, x_17); +x_19 = l_Task_Priority_default; +x_20 = lean_io_as_task(x_18, x_19, x_7); +if (lean_obj_tag(x_20) == 0) +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_20); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_22 = lean_ctor_get(x_20, 0); +x_23 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_5); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_6); +lean_ctor_set(x_20, 0, x_26); +return x_20; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_27 = lean_ctor_get(x_20, 0); +x_28 = lean_ctor_get(x_20, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_20); +x_29 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_27); +lean_ctor_set(x_30, 1, x_29); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_5); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_6); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_28); +return x_33; +} +} +else +{ +uint8_t x_34; +lean_dec(x_6); +lean_dec(x_5); +x_34 = !lean_is_exclusive(x_20); +if (x_34 == 0) +{ +return x_20; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_20, 0); +x_36 = lean_ctor_get(x_20, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_20); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +return x_37; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +lean_dec(x_3); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; lean_object* x_11; +x_10 = lean_unbox(x_5); +lean_dec(x_5); +x_11 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2(x_1, x_2, x_3, x_4, x_10, x_6, x_7, x_8, x_9); +lean_dec(x_6); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; lean_object* x_13; +x_12 = lean_unbox(x_7); +lean_dec(x_7); +x_13 = l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_12, x_8, x_9, x_10, x_11); +lean_dec(x_4); +return x_13; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_fetchOptRelease___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Package_fetchOptRelease___spec__2(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Package_fetchOptRelease___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Package_fetchOptRelease___lambda__2(x_1, x_2, x_3, x_4); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_Package_fetchOptRelease___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_5); +lean_dec(x_4); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchOptRelease___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Package_fetchOptRelease(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_3); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_optReleaseFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Package_fetchOptRelease(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_dec(x_3); +x_4 = lean_box(0); +lean_ctor_set(x_1, 0, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +} +static lean_object* _init_l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___lambda__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Package_optReleaseFacetConfig___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_optReleaseFacetConfig___elambda__1___boxed), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_optReleaseFacetConfig___closed__3; +x_2 = l_Lake_Package_optReleaseFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_optReleaseFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_optReleaseFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_optReleaseFacetConfig___elambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Package_optReleaseFacetConfig___elambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_3); +lean_dec(x_2); +return x_8; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("failed to fetch cloud release", 29); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__2() { +_start: +{ +uint8_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 3; +x_2 = l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__1; +x_3 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_5 = lean_ctor_get(x_2, 0); +x_6 = lean_array_get_size(x_5); +x_7 = l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__2; +x_8 = lean_array_push(x_5, x_7); +lean_ctor_set(x_2, 0, x_8); +x_9 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_9, 0, x_6); +lean_ctor_set(x_9, 1, x_2); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_3); +return x_10; +} +else +{ +lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get_uint8(x_2, sizeof(void*)*1); +lean_inc(x_11); +lean_dec(x_2); +x_13 = lean_array_get_size(x_11); +x_14 = l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__2; +x_15 = lean_array_push(x_11, x_14); +x_16 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set_uint8(x_16, sizeof(void*)*1, x_12); +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_13); +lean_ctor_set(x_17, 1, x_16); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_3); +return x_18; +} +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___boxed), 3, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_4 = lean_ctor_get(x_2, 0); +lean_inc(x_4); +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +lean_dec(x_2); +x_52 = lean_ctor_get(x_4, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_4, 1); +lean_inc(x_53); +lean_dec(x_4); +x_54 = lean_alloc_closure((void*)(l_Lake_Package_recBuildExtraDepTargets___lambda__3___boxed), 5, 1); +lean_closure_set(x_54, 0, x_53); +x_55 = lean_unbox(x_52); +lean_dec(x_52); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; +x_56 = l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2___closed__1; +x_57 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_57, 0, x_56); +lean_closure_set(x_57, 1, x_54); +x_6 = x_57; +goto block_51; +} +else +{ +lean_object* x_58; lean_object* x_59; +x_58 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__5; +x_59 = lean_alloc_closure((void*)(l_ReaderT_bind___at_Lake_buildFileUnlessUpToDate___spec__1___rarg), 5, 2); +lean_closure_set(x_59, 0, x_58); +lean_closure_set(x_59, 1, x_54); +x_6 = x_59; +goto block_51; +} +block_51: +{ +uint8_t x_7; lean_object* x_8; +x_7 = 1; +lean_inc(x_1); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3(x_6, x_7, x_1, x_5, x_3); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_ctor_get(x_9, 1); +lean_inc(x_12); +lean_dec(x_9); +x_13 = lean_ctor_get(x_10, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_10, 1); +lean_inc(x_14); +lean_dec(x_10); +x_15 = l_String_isEmpty(x_13); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; uint8_t x_22; +x_16 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1; +x_17 = lean_string_append(x_16, x_13); +lean_dec(x_13); +x_18 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_19 = lean_string_append(x_17, x_18); +x_20 = 1; +x_21 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set_uint8(x_21, sizeof(void*)*1, x_20); +x_22 = !lean_is_exclusive(x_12); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_12, 0); +x_24 = lean_array_push(x_23, x_21); +lean_ctor_set(x_12, 0, x_24); +x_25 = lean_box(0); +x_26 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_14, x_25, x_1, x_12, x_11); +lean_dec(x_1); +return x_26; +} +else +{ +lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_27 = lean_ctor_get(x_12, 0); +x_28 = lean_ctor_get_uint8(x_12, sizeof(void*)*1); +lean_inc(x_27); +lean_dec(x_12); +x_29 = lean_array_push(x_27, x_21); +x_30 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set_uint8(x_30, sizeof(void*)*1, x_28); +x_31 = lean_box(0); +x_32 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_14, x_31, x_1, x_30, x_11); +lean_dec(x_1); +return x_32; +} +} +else +{ +lean_object* x_33; lean_object* x_34; +lean_dec(x_13); +x_33 = lean_box(0); +x_34 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_14, x_33, x_1, x_12, x_11); +lean_dec(x_1); +return x_34; +} +} +else +{ +uint8_t x_35; +lean_dec(x_1); +x_35 = !lean_is_exclusive(x_8); +if (x_35 == 0) +{ +lean_object* x_36; uint8_t x_37; +x_36 = lean_ctor_get(x_8, 0); +lean_dec(x_36); +x_37 = !lean_is_exclusive(x_9); +if (x_37 == 0) +{ +return x_8; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_9, 0); +x_39 = lean_ctor_get(x_9, 1); +lean_inc(x_39); +lean_inc(x_38); +lean_dec(x_9); +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +lean_ctor_set(x_8, 0, x_40); +return x_8; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_41 = lean_ctor_get(x_8, 1); +lean_inc(x_41); +lean_dec(x_8); +x_42 = lean_ctor_get(x_9, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_9, 1); +lean_inc(x_43); +if (lean_is_exclusive(x_9)) { + lean_ctor_release(x_9, 0); + lean_ctor_release(x_9, 1); + x_44 = x_9; +} else { + lean_dec_ref(x_9); + x_44 = lean_box(0); +} +if (lean_is_scalar(x_44)) { + x_45 = lean_alloc_ctor(1, 2, 0); +} else { + x_45 = x_44; +} +lean_ctor_set(x_45, 0, x_42); +lean_ctor_set(x_45, 1, x_43); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_41); +return x_46; +} +} +} +else +{ +uint8_t x_47; +lean_dec(x_1); +x_47 = !lean_is_exclusive(x_8); +if (x_47 == 0) +{ +return x_8; +} +else +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_8, 0); +x_49 = lean_ctor_get(x_8, 1); +lean_inc(x_49); +lean_inc(x_48); +lean_dec(x_8); +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_48); +lean_ctor_set(x_50, 1, x_49); +return x_50; +} +} +} +} +else +{ +uint8_t x_60; +lean_dec(x_1); +x_60 = !lean_is_exclusive(x_2); +if (x_60 == 0) +{ +lean_object* x_61; +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_2); +lean_ctor_set(x_61, 1, x_3); +return x_61; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_62 = lean_ctor_get(x_2, 0); +x_63 = lean_ctor_get(x_2, 1); +lean_inc(x_63); +lean_inc(x_62); +lean_dec(x_2); +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set(x_64, 1, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_3); +return x_65; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_1); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; +x_9 = lean_ctor_get(x_1, 0); +x_10 = lean_ctor_get(x_1, 1); +x_11 = lean_alloc_closure((void*)(l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2), 3, 1); +lean_closure_set(x_11, 0, x_4); +x_12 = l_Task_Priority_default; +x_13 = 0; +x_14 = lean_io_map_task(x_11, x_9, x_12, x_13, x_7); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_14, 0); +lean_ctor_set(x_1, 0, x_16); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_1); +lean_ctor_set(x_17, 1, x_5); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_6); +lean_ctor_set(x_14, 0, x_18); +return x_14; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_19 = lean_ctor_get(x_14, 0); +x_20 = lean_ctor_get(x_14, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_14); +lean_ctor_set(x_1, 0, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_1); +lean_ctor_set(x_21, 1, x_5); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_6); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_20); +return x_23; +} +} +else +{ +uint8_t x_24; +lean_free_object(x_1); +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +x_24 = !lean_is_exclusive(x_14); +if (x_24 == 0) +{ +return x_14; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_14, 0); +x_26 = lean_ctor_get(x_14, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_14); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; +x_28 = lean_ctor_get(x_1, 0); +x_29 = lean_ctor_get(x_1, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_1); +x_30 = lean_alloc_closure((void*)(l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2), 3, 1); +lean_closure_set(x_30, 0, x_4); +x_31 = l_Task_Priority_default; +x_32 = 0; +x_33 = lean_io_map_task(x_30, x_28, x_31, x_32, x_7); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_36 = x_33; +} else { + lean_dec_ref(x_33); + x_36 = lean_box(0); +} +x_37 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_37, 0, x_34); +lean_ctor_set(x_37, 1, x_29); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_5); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_6); +if (lean_is_scalar(x_36)) { + x_40 = lean_alloc_ctor(0, 2, 0); +} else { + x_40 = x_36; +} +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_35); +return x_40; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_29); +lean_dec(x_6); +lean_dec(x_5); +x_41 = lean_ctor_get(x_33, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_33, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_43 = x_33; +} else { + lean_dec_ref(x_33); + x_43 = lean_box(0); +} +if (lean_is_scalar(x_43)) { + x_44 = lean_alloc_ctor(1, 2, 0); +} else { + x_44 = x_43; +} +lean_ctor_set(x_44, 0, x_41); +lean_ctor_set(x_44, 1, x_42); +return x_44; +} +} +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___elambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":release", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___elambda__1___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_releaseFacetConfig___elambda__1___lambda__3___boxed), 7, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_8 = lean_ctor_get(x_1, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 2); +lean_inc(x_9); +lean_dec(x_8); +x_10 = 1; +x_11 = l_Lean_Name_toString(x_9, x_10); +x_12 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_13 = lean_string_append(x_12, x_11); +lean_dec(x_11); +x_14 = l_Lake_Package_releaseFacetConfig___elambda__1___closed__1; +x_15 = lean_string_append(x_13, x_14); +x_16 = l_Lake_Package_recBuildExtraDepTargets___closed__8; +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_1); +lean_ctor_set(x_17, 1, x_16); +x_18 = lean_alloc_closure((void*)(l_Lake_BuildInfo_fetch___rarg), 8, 2); +lean_closure_set(x_18, 0, x_17); +lean_closure_set(x_18, 1, lean_box(0)); +x_19 = l_Lake_Package_releaseFacetConfig___elambda__1___closed__2; +x_20 = lean_alloc_closure((void*)(l_Lake_EquipT_bind___at_Lake_Package_recBuildExtraDepTargets___spec__7___rarg), 8, 2); +lean_closure_set(x_20, 0, x_18); +lean_closure_set(x_20, 1, x_19); +x_21 = l_Lake_withRegisterJob___rarg(x_15, x_20, x_2, x_3, x_4, x_5, x_6, x_7); +return x_21; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("release", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_Package_releaseFacetConfig___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_releaseFacetConfig___elambda__1), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_releaseFacetConfig___closed__3; +x_2 = l_Lake_Package_extraDepFacetConfig___closed__2; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_releaseFacetConfig() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Package_releaseFacetConfig___closed__4; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_releaseFacetConfig___elambda__1___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Package_releaseFacetConfig___elambda__1___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_3); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync___rarg___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 1); +x_5 = l_Lake_JobState_merge(x_1, x_4); +lean_ctor_set(x_2, 1, x_5); +return x_2; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +lean_inc(x_7); +lean_inc(x_6); +lean_dec(x_2); +x_8 = l_Lake_JobState_merge(x_1, x_7); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_6); +lean_ctor_set(x_9, 1, x_8); +return x_9; +} +} +else +{ +uint8_t x_10; +x_10 = !lean_is_exclusive(x_2); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_2, 0); +x_12 = lean_ctor_get(x_2, 1); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = lean_array_get_size(x_13); +lean_dec(x_13); +x_15 = lean_nat_add(x_14, x_11); +lean_dec(x_11); +lean_dec(x_14); +x_16 = l_Lake_JobState_merge(x_1, x_12); +lean_ctor_set(x_2, 1, x_16); +lean_ctor_set(x_2, 0, x_15); +return x_2; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_17 = lean_ctor_get(x_2, 0); +x_18 = lean_ctor_get(x_2, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_2); +x_19 = lean_ctor_get(x_1, 0); +lean_inc(x_19); +x_20 = lean_array_get_size(x_19); +lean_dec(x_19); +x_21 = lean_nat_add(x_20, x_17); +lean_dec(x_17); +lean_dec(x_20); +x_22 = l_Lake_JobState_merge(x_1, x_18); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set(x_23, 1, x_22); +return x_23; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = lean_apply_2(x_1, x_2, x_4); +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; +x_8 = lean_ctor_get(x_6, 0); +x_9 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseAsync___rarg___lambda__1), 2, 1); +lean_closure_set(x_9, 0, x_5); +x_10 = lean_ctor_get(x_8, 0); +lean_inc(x_10); +lean_dec(x_8); +x_11 = l_Task_Priority_default; +x_12 = 1; +x_13 = lean_task_map(x_9, x_10, x_11, x_12); +lean_ctor_set(x_6, 0, x_13); +return x_6; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; +x_14 = lean_ctor_get(x_6, 0); +x_15 = lean_ctor_get(x_6, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_6); +x_16 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseAsync___rarg___lambda__1), 2, 1); +lean_closure_set(x_16, 0, x_5); +x_17 = lean_ctor_get(x_14, 0); +lean_inc(x_17); +lean_dec(x_14); +x_18 = l_Task_Priority_default; +x_19 = 1; +x_20 = lean_task_map(x_16, x_17, x_18, x_19); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_15); +return x_21; +} +} +else +{ +uint8_t x_22; +lean_dec(x_5); +x_22 = !lean_is_exclusive(x_6); +if (x_22 == 0) +{ +return x_6; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +return x_25; +} +} +} +else +{ +uint8_t x_26; +lean_dec(x_2); +lean_dec(x_1); +x_26 = !lean_is_exclusive(x_3); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_task_pure(x_3); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_4); +return x_28; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_29 = lean_ctor_get(x_3, 0); +x_30 = lean_ctor_get(x_3, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_3); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +x_32 = lean_task_pure(x_31); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set(x_33, 1, x_4); +return x_33; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_1, 2); +lean_inc(x_9); +x_10 = lean_ctor_get_uint8(x_9, sizeof(void*)*21 + 1); +if (x_10 == 0) +{ +lean_object* x_11; +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_11 = lean_apply_2(x_2, x_5, x_8); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_13 = lean_ctor_get(x_11, 0); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_6); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_7); +lean_ctor_set(x_11, 0, x_15); +return x_11; +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_16 = lean_ctor_get(x_11, 0); +x_17 = lean_ctor_get(x_11, 1); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_11); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set(x_18, 1, x_6); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_7); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_17); +return x_20; +} +} +else +{ +uint8_t x_21; +lean_dec(x_7); +lean_dec(x_6); +x_21 = !lean_is_exclusive(x_11); +if (x_21 == 0) +{ +return x_11; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_11); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +return x_24; +} +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; uint8_t x_31; +x_25 = lean_ctor_get(x_5, 1); +lean_inc(x_25); +x_26 = lean_ctor_get(x_25, 0); +lean_inc(x_26); +lean_dec(x_25); +x_27 = lean_ctor_get(x_9, 2); +lean_inc(x_27); +lean_dec(x_9); +x_28 = lean_ctor_get(x_26, 2); +lean_inc(x_28); +lean_dec(x_26); +x_29 = lean_ctor_get(x_28, 2); +lean_inc(x_29); +lean_dec(x_28); +x_30 = lean_name_eq(x_27, x_29); +lean_dec(x_29); +lean_dec(x_27); +x_31 = l_instDecidableNot___rarg(x_30); +if (x_31 == 0) +{ +lean_object* x_32; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_32 = lean_apply_2(x_2, x_5, x_8); +if (lean_obj_tag(x_32) == 0) +{ +uint8_t x_33; +x_33 = !lean_is_exclusive(x_32); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_32, 0); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_6); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_7); +lean_ctor_set(x_32, 0, x_36); +return x_32; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_37 = lean_ctor_get(x_32, 0); +x_38 = lean_ctor_get(x_32, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_32); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_6); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_7); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_38); +return x_41; +} +} +else +{ +uint8_t x_42; +lean_dec(x_7); +lean_dec(x_6); +x_42 = !lean_is_exclusive(x_32); +if (x_42 == 0) +{ +return x_32; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_32, 0); +x_44 = lean_ctor_get(x_32, 1); +lean_inc(x_44); +lean_inc(x_43); +lean_dec(x_32); +x_45 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_45, 0, x_43); +lean_ctor_set(x_45, 1, x_44); +return x_45; +} +} +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = l_Lake_Package_releaseFacetConfig___closed__2; +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_1); +lean_ctor_set(x_47, 1, x_46); +lean_inc(x_5); +x_48 = lean_apply_6(x_3, x_47, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; lean_object* x_52; uint8_t x_53; +x_51 = lean_ctor_get(x_50, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_48, 1); +lean_inc(x_52); +lean_dec(x_48); +x_53 = !lean_is_exclusive(x_49); +if (x_53 == 0) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_49, 1); +x_55 = lean_ctor_get(x_49, 0); +lean_dec(x_55); +x_56 = !lean_is_exclusive(x_50); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; uint8_t x_59; +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_ctor_get(x_50, 0); +lean_dec(x_58); +x_59 = !lean_is_exclusive(x_51); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; lean_object* x_65; +x_60 = lean_ctor_get(x_51, 0); +x_61 = lean_ctor_get(x_51, 1); +x_62 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseAsync___rarg___lambda__2), 4, 2); +lean_closure_set(x_62, 0, x_2); +lean_closure_set(x_62, 1, x_5); +x_63 = l_Task_Priority_default; +x_64 = 0; +x_65 = lean_io_bind_task(x_60, x_62, x_63, x_64, x_52); +if (lean_obj_tag(x_65) == 0) +{ +uint8_t x_66; +x_66 = !lean_is_exclusive(x_65); +if (x_66 == 0) +{ +lean_object* x_67; +x_67 = lean_ctor_get(x_65, 0); +lean_ctor_set(x_51, 0, x_67); +lean_ctor_set(x_65, 0, x_49); +return x_65; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_65, 0); +x_69 = lean_ctor_get(x_65, 1); +lean_inc(x_69); +lean_inc(x_68); +lean_dec(x_65); +lean_ctor_set(x_51, 0, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_49); +lean_ctor_set(x_70, 1, x_69); +return x_70; +} +} +else +{ +uint8_t x_71; +lean_free_object(x_51); +lean_dec(x_61); +lean_free_object(x_50); +lean_dec(x_57); +lean_free_object(x_49); +lean_dec(x_54); +x_71 = !lean_is_exclusive(x_65); +if (x_71 == 0) +{ +return x_65; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_72 = lean_ctor_get(x_65, 0); +x_73 = lean_ctor_get(x_65, 1); +lean_inc(x_73); +lean_inc(x_72); +lean_dec(x_65); +x_74 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_74, 0, x_72); +lean_ctor_set(x_74, 1, x_73); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; lean_object* x_80; +x_75 = lean_ctor_get(x_51, 0); +x_76 = lean_ctor_get(x_51, 1); +lean_inc(x_76); +lean_inc(x_75); +lean_dec(x_51); +x_77 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseAsync___rarg___lambda__2), 4, 2); +lean_closure_set(x_77, 0, x_2); +lean_closure_set(x_77, 1, x_5); +x_78 = l_Task_Priority_default; +x_79 = 0; +x_80 = lean_io_bind_task(x_75, x_77, x_78, x_79, x_52); +if (lean_obj_tag(x_80) == 0) +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_81 = lean_ctor_get(x_80, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_80, 1); +lean_inc(x_82); +if (lean_is_exclusive(x_80)) { + lean_ctor_release(x_80, 0); + lean_ctor_release(x_80, 1); + x_83 = x_80; +} else { + lean_dec_ref(x_80); + x_83 = lean_box(0); +} +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_81); +lean_ctor_set(x_84, 1, x_76); +lean_ctor_set(x_50, 0, x_84); +if (lean_is_scalar(x_83)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_83; +} +lean_ctor_set(x_85, 0, x_49); +lean_ctor_set(x_85, 1, x_82); +return x_85; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +lean_dec(x_76); +lean_free_object(x_50); +lean_dec(x_57); +lean_free_object(x_49); +lean_dec(x_54); +x_86 = lean_ctor_get(x_80, 0); +lean_inc(x_86); +x_87 = lean_ctor_get(x_80, 1); +lean_inc(x_87); +if (lean_is_exclusive(x_80)) { + lean_ctor_release(x_80, 0); + lean_ctor_release(x_80, 1); + x_88 = x_80; +} else { + lean_dec_ref(x_80); + x_88 = lean_box(0); +} +if (lean_is_scalar(x_88)) { + x_89 = lean_alloc_ctor(1, 2, 0); +} else { + x_89 = x_88; +} +lean_ctor_set(x_89, 0, x_86); +lean_ctor_set(x_89, 1, x_87); +return x_89; +} +} +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; +x_90 = lean_ctor_get(x_50, 1); +lean_inc(x_90); +lean_dec(x_50); +x_91 = lean_ctor_get(x_51, 0); +lean_inc(x_91); +x_92 = lean_ctor_get(x_51, 1); +lean_inc(x_92); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_93 = x_51; +} else { + lean_dec_ref(x_51); + x_93 = lean_box(0); +} +x_94 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseAsync___rarg___lambda__2), 4, 2); +lean_closure_set(x_94, 0, x_2); +lean_closure_set(x_94, 1, x_5); +x_95 = l_Task_Priority_default; +x_96 = 0; +x_97 = lean_io_bind_task(x_91, x_94, x_95, x_96, x_52); +if (lean_obj_tag(x_97) == 0) +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_98 = lean_ctor_get(x_97, 0); +lean_inc(x_98); +x_99 = lean_ctor_get(x_97, 1); +lean_inc(x_99); +if (lean_is_exclusive(x_97)) { + lean_ctor_release(x_97, 0); + lean_ctor_release(x_97, 1); + x_100 = x_97; +} else { + lean_dec_ref(x_97); + x_100 = lean_box(0); +} +if (lean_is_scalar(x_93)) { + x_101 = lean_alloc_ctor(0, 2, 0); +} else { + x_101 = x_93; +} +lean_ctor_set(x_101, 0, x_98); +lean_ctor_set(x_101, 1, x_92); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_101); +lean_ctor_set(x_102, 1, x_90); +lean_ctor_set(x_49, 0, x_102); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 2, 0); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_49); +lean_ctor_set(x_103, 1, x_99); +return x_103; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +lean_dec(x_93); +lean_dec(x_92); +lean_dec(x_90); +lean_free_object(x_49); +lean_dec(x_54); +x_104 = lean_ctor_get(x_97, 0); +lean_inc(x_104); +x_105 = lean_ctor_get(x_97, 1); +lean_inc(x_105); +if (lean_is_exclusive(x_97)) { + lean_ctor_release(x_97, 0); + lean_ctor_release(x_97, 1); + x_106 = x_97; +} else { + lean_dec_ref(x_97); + x_106 = lean_box(0); +} +if (lean_is_scalar(x_106)) { + x_107 = lean_alloc_ctor(1, 2, 0); +} else { + x_107 = x_106; +} +lean_ctor_set(x_107, 0, x_104); +lean_ctor_set(x_107, 1, x_105); +return x_107; +} +} +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; lean_object* x_117; +x_108 = lean_ctor_get(x_49, 1); +lean_inc(x_108); +lean_dec(x_49); +x_109 = lean_ctor_get(x_50, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_110 = x_50; +} else { + lean_dec_ref(x_50); + x_110 = lean_box(0); +} +x_111 = lean_ctor_get(x_51, 0); +lean_inc(x_111); +x_112 = lean_ctor_get(x_51, 1); +lean_inc(x_112); +if (lean_is_exclusive(x_51)) { + lean_ctor_release(x_51, 0); + lean_ctor_release(x_51, 1); + x_113 = x_51; +} else { + lean_dec_ref(x_51); + x_113 = lean_box(0); +} +x_114 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseAsync___rarg___lambda__2), 4, 2); +lean_closure_set(x_114, 0, x_2); +lean_closure_set(x_114, 1, x_5); +x_115 = l_Task_Priority_default; +x_116 = 0; +x_117 = lean_io_bind_task(x_111, x_114, x_115, x_116, x_52); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +x_118 = lean_ctor_get(x_117, 0); +lean_inc(x_118); +x_119 = lean_ctor_get(x_117, 1); +lean_inc(x_119); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_120 = x_117; +} else { + lean_dec_ref(x_117); + x_120 = lean_box(0); +} +if (lean_is_scalar(x_113)) { + x_121 = lean_alloc_ctor(0, 2, 0); +} else { + x_121 = x_113; +} +lean_ctor_set(x_121, 0, x_118); +lean_ctor_set(x_121, 1, x_112); +if (lean_is_scalar(x_110)) { + x_122 = lean_alloc_ctor(0, 2, 0); +} else { + x_122 = x_110; +} +lean_ctor_set(x_122, 0, x_121); +lean_ctor_set(x_122, 1, x_109); +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_122); +lean_ctor_set(x_123, 1, x_108); +if (lean_is_scalar(x_120)) { + x_124 = lean_alloc_ctor(0, 2, 0); +} else { + x_124 = x_120; +} +lean_ctor_set(x_124, 0, x_123); +lean_ctor_set(x_124, 1, x_119); +return x_124; +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; +lean_dec(x_113); +lean_dec(x_112); +lean_dec(x_110); +lean_dec(x_109); +lean_dec(x_108); +x_125 = lean_ctor_get(x_117, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_117, 1); +lean_inc(x_126); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_127 = x_117; +} else { + lean_dec_ref(x_117); + x_127 = lean_box(0); +} +if (lean_is_scalar(x_127)) { + x_128 = lean_alloc_ctor(1, 2, 0); +} else { + x_128 = x_127; +} +lean_ctor_set(x_128, 0, x_125); +lean_ctor_set(x_128, 1, x_126); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_5); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_48); +if (x_129 == 0) +{ +lean_object* x_130; uint8_t x_131; +x_130 = lean_ctor_get(x_48, 0); +lean_dec(x_130); +x_131 = !lean_is_exclusive(x_49); +if (x_131 == 0) +{ +lean_object* x_132; uint8_t x_133; +x_132 = lean_ctor_get(x_49, 0); +lean_dec(x_132); +x_133 = !lean_is_exclusive(x_50); +if (x_133 == 0) +{ +return x_48; +} +else +{ +lean_object* x_134; lean_object* x_135; lean_object* x_136; +x_134 = lean_ctor_get(x_50, 0); +x_135 = lean_ctor_get(x_50, 1); +lean_inc(x_135); +lean_inc(x_134); +lean_dec(x_50); +x_136 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_136, 0, x_134); +lean_ctor_set(x_136, 1, x_135); +lean_ctor_set(x_49, 0, x_136); +return x_48; +} +} +else +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; +x_137 = lean_ctor_get(x_49, 1); +lean_inc(x_137); +lean_dec(x_49); +x_138 = lean_ctor_get(x_50, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_50, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_140 = x_50; +} else { + lean_dec_ref(x_50); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_137); +lean_ctor_set(x_48, 0, x_142); +return x_48; +} +} +else +{ +lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_143 = lean_ctor_get(x_48, 1); +lean_inc(x_143); +lean_dec(x_48); +x_144 = lean_ctor_get(x_49, 1); +lean_inc(x_144); +if (lean_is_exclusive(x_49)) { + lean_ctor_release(x_49, 0); + lean_ctor_release(x_49, 1); + x_145 = x_49; +} else { + lean_dec_ref(x_49); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_50, 0); +lean_inc(x_146); +x_147 = lean_ctor_get(x_50, 1); +lean_inc(x_147); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_148 = x_50; +} else { + lean_dec_ref(x_50); + x_148 = lean_box(0); +} +if (lean_is_scalar(x_148)) { + x_149 = lean_alloc_ctor(1, 2, 0); +} else { + x_149 = x_148; +} +lean_ctor_set(x_149, 0, x_146); +lean_ctor_set(x_149, 1, x_147); +if (lean_is_scalar(x_145)) { + x_150 = lean_alloc_ctor(0, 2, 0); +} else { + x_150 = x_145; +} +lean_ctor_set(x_150, 0, x_149); +lean_ctor_set(x_150, 1, x_144); +x_151 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_151, 0, x_150); +lean_ctor_set(x_151, 1, x_143); +return x_151; +} +} +} +else +{ +uint8_t x_152; +lean_dec(x_5); +lean_dec(x_2); +x_152 = !lean_is_exclusive(x_48); +if (x_152 == 0) +{ +return x_48; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; +x_153 = lean_ctor_get(x_48, 0); +x_154 = lean_ctor_get(x_48, 1); +lean_inc(x_154); +lean_inc(x_153); +lean_dec(x_48); +x_155 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_155, 0, x_153); +lean_ctor_set(x_155, 1, x_154); +return x_155; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseAsync(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseAsync___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__2(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__2___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__3___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__4(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__4___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__5___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__5(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__5___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__6___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__2___rarg), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__3___rarg(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__4___rarg), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__5___rarg), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__6___rarg(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__2___rarg), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__3___rarg(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__4___rarg), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__5___rarg), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__6___rarg(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__8___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__8(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__8___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__9___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__9(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__9___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__10___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stderr(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stderr(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stderr(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stderr(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stderr(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__10(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__10___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__11___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdout(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdout(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdout(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdout(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdout(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__11(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__11___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__12___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_28; +x_28 = !lean_is_exclusive(x_4); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_4, 0); +x_30 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_30) == 0) +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +x_33 = lean_apply_3(x_2, x_3, x_4, x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_33, 1); +lean_inc(x_36); +lean_dec(x_33); +x_37 = !lean_is_exclusive(x_34); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_38 = lean_ctor_get(x_34, 0); +x_39 = lean_ctor_get(x_34, 1); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_42, 1); +lean_inc(x_43); +lean_dec(x_42); +x_44 = lean_box(0); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_38); +lean_ctor_set(x_45, 1, x_44); +lean_ctor_set(x_34, 0, x_45); +x_6 = x_34; +x_7 = x_43; +goto block_27; +} +else +{ +uint8_t x_46; +lean_free_object(x_35); +lean_dec(x_41); +lean_free_object(x_34); +lean_dec(x_38); +x_46 = !lean_is_exclusive(x_42); +if (x_46 == 0) +{ +return x_42; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_42, 0); +x_48 = lean_ctor_get(x_42, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +lean_object* x_50; uint8_t x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_35, 0); +x_51 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +lean_inc(x_50); +lean_dec(x_35); +x_52 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_53); +lean_dec(x_52); +x_54 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_54, 0, x_50); +lean_ctor_set_uint8(x_54, sizeof(void*)*1, x_51); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_38); +lean_ctor_set(x_56, 1, x_55); +lean_ctor_set(x_34, 1, x_54); +lean_ctor_set(x_34, 0, x_56); +x_6 = x_34; +x_7 = x_53; +goto block_27; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_dec(x_50); +lean_free_object(x_34); +lean_dec(x_38); +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_52, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_52)) { + lean_ctor_release(x_52, 0); + lean_ctor_release(x_52, 1); + x_59 = x_52; +} else { + lean_dec_ref(x_52); + x_59 = lean_box(0); +} +if (lean_is_scalar(x_59)) { + x_60 = lean_alloc_ctor(1, 2, 0); +} else { + x_60 = x_59; +} +lean_ctor_set(x_60, 0, x_57); +lean_ctor_set(x_60, 1, x_58); +return x_60; +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_34, 0); +lean_inc(x_61); +lean_dec(x_34); +x_62 = lean_ctor_get(x_35, 0); +lean_inc(x_62); +x_63 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + x_64 = x_35; +} else { + lean_dec_ref(x_35); + x_64 = lean_box(0); +} +x_65 = lean_get_set_stdin(x_31, x_36); +if (lean_obj_tag(x_65) == 0) +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_66 = lean_ctor_get(x_65, 1); +lean_inc(x_66); +lean_dec(x_65); +if (lean_is_scalar(x_64)) { + x_67 = lean_alloc_ctor(0, 1, 1); +} else { + x_67 = x_64; +} +lean_ctor_set(x_67, 0, x_62); +lean_ctor_set_uint8(x_67, sizeof(void*)*1, x_63); +x_68 = lean_box(0); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_61); +lean_ctor_set(x_69, 1, x_68); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +x_6 = x_70; +x_7 = x_66; +goto block_27; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_64); +lean_dec(x_62); +lean_dec(x_61); +x_71 = lean_ctor_get(x_65, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_65, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_65)) { + lean_ctor_release(x_65, 0); + lean_ctor_release(x_65, 1); + x_73 = x_65; +} else { + lean_dec_ref(x_65); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_75 = lean_ctor_get(x_34, 1); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +lean_dec(x_33); +x_77 = !lean_is_exclusive(x_34); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_78 = lean_ctor_get(x_34, 0); +x_79 = lean_ctor_get(x_34, 1); +lean_dec(x_79); +x_80 = !lean_is_exclusive(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_75, 0); +x_82 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_82) == 0) +{ +lean_object* x_83; +x_83 = lean_ctor_get(x_82, 1); +lean_inc(x_83); +lean_dec(x_82); +x_6 = x_34; +x_7 = x_83; +goto block_27; +} +else +{ +uint8_t x_84; +lean_free_object(x_75); +lean_dec(x_81); +lean_free_object(x_34); +lean_dec(x_78); +x_84 = !lean_is_exclusive(x_82); +if (x_84 == 0) +{ +return x_82; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_82, 0); +x_86 = lean_ctor_get(x_82, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_82); +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 +{ +lean_object* x_88; uint8_t x_89; lean_object* x_90; +x_88 = lean_ctor_get(x_75, 0); +x_89 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +lean_inc(x_88); +lean_dec(x_75); +x_90 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; +x_91 = lean_ctor_get(x_90, 1); +lean_inc(x_91); +lean_dec(x_90); +x_92 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_92, 0, x_88); +lean_ctor_set_uint8(x_92, sizeof(void*)*1, x_89); +lean_ctor_set(x_34, 1, x_92); +x_6 = x_34; +x_7 = x_91; +goto block_27; +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_88); +lean_free_object(x_34); +lean_dec(x_78); +x_93 = lean_ctor_get(x_90, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_90, 1); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + lean_ctor_release(x_90, 1); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +if (lean_is_scalar(x_95)) { + x_96 = lean_alloc_ctor(1, 2, 0); +} else { + x_96 = x_95; +} +lean_ctor_set(x_96, 0, x_93); +lean_ctor_set(x_96, 1, x_94); +return x_96; +} +} +} +else +{ +lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_34, 0); +lean_inc(x_97); +lean_dec(x_34); +x_98 = lean_ctor_get(x_75, 0); +lean_inc(x_98); +x_99 = lean_ctor_get_uint8(x_75, sizeof(void*)*1); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + x_100 = x_75; +} else { + lean_dec_ref(x_75); + x_100 = lean_box(0); +} +x_101 = lean_get_set_stdin(x_31, x_76); +if (lean_obj_tag(x_101) == 0) +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_102 = lean_ctor_get(x_101, 1); +lean_inc(x_102); +lean_dec(x_101); +if (lean_is_scalar(x_100)) { + x_103 = lean_alloc_ctor(0, 1, 1); +} else { + x_103 = x_100; +} +lean_ctor_set(x_103, 0, x_98); +lean_ctor_set_uint8(x_103, sizeof(void*)*1, x_99); +x_104 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_104, 0, x_97); +lean_ctor_set(x_104, 1, x_103); +x_6 = x_104; +x_7 = x_102; +goto block_27; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +lean_dec(x_100); +lean_dec(x_98); +lean_dec(x_97); +x_105 = lean_ctor_get(x_101, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_101, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_101)) { + lean_ctor_release(x_101, 0); + lean_ctor_release(x_101, 1); + x_107 = x_101; +} else { + lean_dec_ref(x_101); + x_107 = lean_box(0); +} +if (lean_is_scalar(x_107)) { + x_108 = lean_alloc_ctor(1, 2, 0); +} else { + x_108 = x_107; +} +lean_ctor_set(x_108, 0, x_105); +lean_ctor_set(x_108, 1, x_106); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_31); +x_109 = !lean_is_exclusive(x_33); +if (x_109 == 0) +{ +return x_33; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_33, 0); +x_111 = lean_ctor_get(x_33, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_33); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_4); +lean_dec(x_29); +lean_dec(x_3); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_30); +if (x_113 == 0) +{ +return x_30; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_30, 0); +x_115 = lean_ctor_get(x_30, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_30); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; uint8_t x_118; lean_object* x_119; +x_117 = lean_ctor_get(x_4, 0); +x_118 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_117); +lean_dec(x_4); +x_119 = lean_get_set_stdin(x_1, x_5); +if (lean_obj_tag(x_119) == 0) +{ +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +x_122 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_122, 0, x_117); +lean_ctor_set_uint8(x_122, sizeof(void*)*1, x_118); +x_123 = lean_apply_3(x_2, x_3, x_122, x_121); +if (lean_obj_tag(x_123) == 0) +{ +lean_object* x_124; +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +if (lean_obj_tag(x_124) == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; lean_object* x_132; +x_125 = lean_ctor_get(x_124, 1); +lean_inc(x_125); +x_126 = lean_ctor_get(x_123, 1); +lean_inc(x_126); +lean_dec(x_123); +x_127 = lean_ctor_get(x_124, 0); +lean_inc(x_127); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_128 = x_124; +} else { + lean_dec_ref(x_124); + x_128 = lean_box(0); +} +x_129 = lean_ctor_get(x_125, 0); +lean_inc(x_129); +x_130 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); +if (lean_is_exclusive(x_125)) { + lean_ctor_release(x_125, 0); + x_131 = x_125; +} else { + lean_dec_ref(x_125); + x_131 = lean_box(0); +} +x_132 = lean_get_set_stdin(x_120, x_126); +if (lean_obj_tag(x_132) == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_133 = lean_ctor_get(x_132, 1); +lean_inc(x_133); +lean_dec(x_132); +if (lean_is_scalar(x_131)) { + x_134 = lean_alloc_ctor(0, 1, 1); +} else { + x_134 = x_131; +} +lean_ctor_set(x_134, 0, x_129); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_130); +x_135 = lean_box(0); +x_136 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_136, 0, x_127); +lean_ctor_set(x_136, 1, x_135); +if (lean_is_scalar(x_128)) { + x_137 = lean_alloc_ctor(0, 2, 0); +} else { + x_137 = x_128; +} +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_134); +x_6 = x_137; +x_7 = x_133; +goto block_27; +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_131); +lean_dec(x_129); +lean_dec(x_128); +lean_dec(x_127); +x_138 = lean_ctor_get(x_132, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_132, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_132)) { + lean_ctor_release(x_132, 0); + lean_ctor_release(x_132, 1); + x_140 = x_132; +} else { + lean_dec_ref(x_132); + x_140 = lean_box(0); +} +if (lean_is_scalar(x_140)) { + x_141 = lean_alloc_ctor(1, 2, 0); +} else { + x_141 = x_140; +} +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_139); +return x_141; +} +} +else +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +x_142 = lean_ctor_get(x_124, 1); +lean_inc(x_142); +x_143 = lean_ctor_get(x_123, 1); +lean_inc(x_143); +lean_dec(x_123); +x_144 = lean_ctor_get(x_124, 0); +lean_inc(x_144); +if (lean_is_exclusive(x_124)) { + lean_ctor_release(x_124, 0); + lean_ctor_release(x_124, 1); + x_145 = x_124; +} else { + lean_dec_ref(x_124); + x_145 = lean_box(0); +} +x_146 = lean_ctor_get(x_142, 0); +lean_inc(x_146); +x_147 = lean_ctor_get_uint8(x_142, sizeof(void*)*1); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + x_148 = x_142; +} else { + lean_dec_ref(x_142); + x_148 = lean_box(0); +} +x_149 = lean_get_set_stdin(x_120, x_143); +if (lean_obj_tag(x_149) == 0) +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_149, 1); +lean_inc(x_150); +lean_dec(x_149); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 1, 1); +} else { + x_151 = x_148; +} +lean_ctor_set(x_151, 0, x_146); +lean_ctor_set_uint8(x_151, sizeof(void*)*1, x_147); +if (lean_is_scalar(x_145)) { + x_152 = lean_alloc_ctor(1, 2, 0); +} else { + x_152 = x_145; +} +lean_ctor_set(x_152, 0, x_144); +lean_ctor_set(x_152, 1, x_151); +x_6 = x_152; +x_7 = x_150; +goto block_27; +} +else +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_148); +lean_dec(x_146); +lean_dec(x_145); +lean_dec(x_144); +x_153 = lean_ctor_get(x_149, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_149, 1); +lean_inc(x_154); +if (lean_is_exclusive(x_149)) { + lean_ctor_release(x_149, 0); + lean_ctor_release(x_149, 1); + x_155 = x_149; +} else { + lean_dec_ref(x_149); + x_155 = lean_box(0); +} +if (lean_is_scalar(x_155)) { + x_156 = lean_alloc_ctor(1, 2, 0); +} else { + x_156 = x_155; +} +lean_ctor_set(x_156, 0, x_153); +lean_ctor_set(x_156, 1, x_154); +return x_156; +} +} +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_120); +x_157 = lean_ctor_get(x_123, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_123, 1); +lean_inc(x_158); +if (lean_is_exclusive(x_123)) { + lean_ctor_release(x_123, 0); + lean_ctor_release(x_123, 1); + x_159 = x_123; +} else { + lean_dec_ref(x_123); + x_159 = lean_box(0); +} +if (lean_is_scalar(x_159)) { + x_160 = lean_alloc_ctor(1, 2, 0); +} else { + x_160 = x_159; +} +lean_ctor_set(x_160, 0, x_157); +lean_ctor_set(x_160, 1, x_158); +return x_160; +} +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +lean_dec(x_117); +lean_dec(x_3); +lean_dec(x_2); +x_161 = lean_ctor_get(x_119, 0); +lean_inc(x_161); +x_162 = lean_ctor_get(x_119, 1); +lean_inc(x_162); +if (lean_is_exclusive(x_119)) { + lean_ctor_release(x_119, 0); + lean_ctor_release(x_119, 1); + x_163 = x_119; +} else { + lean_dec_ref(x_119); + x_163 = lean_box(0); +} +if (lean_is_scalar(x_163)) { + x_164 = lean_alloc_ctor(1, 2, 0); +} else { + x_164 = x_163; +} +lean_ctor_set(x_164, 0, x_161); +lean_ctor_set(x_164, 1, x_162); +return x_164; +} +} +block_27: +{ +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_ctor_get(x_6, 0); +x_10 = !lean_is_exclusive(x_9); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_9, 0); +x_12 = lean_ctor_get(x_9, 1); +lean_dec(x_12); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_9, 1, x_7); +lean_ctor_set(x_9, 0, x_6); +return x_9; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +lean_dec(x_9); +lean_ctor_set(x_6, 0, x_13); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_6); +lean_ctor_set(x_14, 1, x_7); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_6, 0); +x_16 = lean_ctor_get(x_6, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_6); +x_17 = lean_ctor_get(x_15, 0); +lean_inc(x_17); +if (lean_is_exclusive(x_15)) { + lean_ctor_release(x_15, 0); + lean_ctor_release(x_15, 1); + x_18 = x_15; +} else { + lean_dec_ref(x_15); + x_18 = lean_box(0); +} +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_16); +if (lean_is_scalar(x_18)) { + x_20 = lean_alloc_ctor(0, 2, 0); +} else { + x_20 = x_18; +} +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_7); +return x_20; +} +} +else +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_6); +if (x_21 == 0) +{ +lean_object* x_22; +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_6); +lean_ctor_set(x_22, 1, x_7); +return x_22; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_6, 0); +x_24 = lean_ctor_get(x_6, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_6); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_7); +return x_26; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__12(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__12___rarg), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_4, 0); +x_8 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_9 = lean_st_mk_ref(x_8, x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_9, 1); +lean_inc(x_11); +lean_dec(x_9); +x_12 = lean_st_mk_ref(x_8, x_11); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_IO_FS_Stream_ofBuffer(x_10); +lean_inc(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_13); +if (x_2 == 0) +{ +lean_object* x_17; lean_object* x_18; +x_17 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__8___rarg), 5, 2); +lean_closure_set(x_17, 0, x_16); +lean_closure_set(x_17, 1, x_1); +x_18 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__9___rarg(x_15, x_17, x_3, x_4, x_14); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_18, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +x_21 = lean_ctor_get(x_18, 1); +lean_inc(x_21); +lean_dec(x_18); +x_22 = !lean_is_exclusive(x_19); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +lean_dec(x_24); +x_25 = !lean_is_exclusive(x_20); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_20, 0); +x_27 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_27) == 0) +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_27); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_27, 0); +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +lean_dec(x_29); +x_31 = lean_string_validate_utf8(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_dec(x_30); +x_32 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_33 = l_panic___at_String_fromUTF8_x21___spec__1(x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_23); +lean_ctor_set(x_19, 0, x_34); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +else +{ +lean_object* x_35; lean_object* x_36; +x_35 = lean_string_from_utf8(x_30); +lean_dec(x_30); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_35); +lean_ctor_set(x_36, 1, x_23); +lean_ctor_set(x_19, 0, x_36); +lean_ctor_set(x_27, 0, x_19); +return x_27; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_37 = lean_ctor_get(x_27, 0); +x_38 = lean_ctor_get(x_27, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_27); +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_string_validate_utf8(x_39); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +x_41 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_42 = l_panic___at_String_fromUTF8_x21___spec__1(x_41); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_23); +lean_ctor_set(x_19, 0, x_43); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_19); +lean_ctor_set(x_44, 1, x_38); +return x_44; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_string_from_utf8(x_39); +lean_dec(x_39); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_23); +lean_ctor_set(x_19, 0, x_46); +x_47 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_47, 0, x_19); +lean_ctor_set(x_47, 1, x_38); +return x_47; +} +} +} +else +{ +uint8_t x_48; +lean_free_object(x_20); +lean_dec(x_26); +lean_free_object(x_19); +lean_dec(x_23); +x_48 = !lean_is_exclusive(x_27); +if (x_48 == 0) +{ +return x_27; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_27, 0); +x_50 = lean_ctor_get(x_27, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_27); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_54) == 0) +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_57 = x_54; +} else { + lean_dec_ref(x_54); + x_57 = lean_box(0); +} +x_58 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_58, 0, x_52); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_53); +x_59 = lean_ctor_get(x_55, 0); +lean_inc(x_59); +lean_dec(x_55); +x_60 = lean_string_validate_utf8(x_59); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_59); +x_61 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_62 = l_panic___at_String_fromUTF8_x21___spec__1(x_61); +x_63 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_63); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_19); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_string_from_utf8(x_59); +lean_dec(x_59); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_23); +lean_ctor_set(x_19, 1, x_58); +lean_ctor_set(x_19, 0, x_66); +if (lean_is_scalar(x_57)) { + x_67 = lean_alloc_ctor(0, 2, 0); +} else { + x_67 = x_57; +} +lean_ctor_set(x_67, 0, x_19); +lean_ctor_set(x_67, 1, x_56); +return x_67; +} +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_52); +lean_free_object(x_19); +lean_dec(x_23); +x_68 = lean_ctor_get(x_54, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_54, 1); +lean_inc(x_69); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_70 = x_54; +} else { + lean_dec_ref(x_54); + x_70 = lean_box(0); +} +if (lean_is_scalar(x_70)) { + x_71 = lean_alloc_ctor(1, 2, 0); +} else { + x_71 = x_70; +} +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = lean_ctor_get(x_19, 0); +lean_inc(x_72); +lean_dec(x_19); +x_73 = lean_ctor_get(x_20, 0); +lean_inc(x_73); +x_74 = lean_ctor_get_uint8(x_20, sizeof(void*)*1); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + x_75 = x_20; +} else { + lean_dec_ref(x_20); + x_75 = lean_box(0); +} +x_76 = lean_st_ref_get(x_13, x_21); +lean_dec(x_13); +if (lean_obj_tag(x_76) == 0) +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_79 = x_76; +} else { + lean_dec_ref(x_76); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_80 = lean_alloc_ctor(0, 1, 1); +} else { + x_80 = x_75; +} +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set_uint8(x_80, sizeof(void*)*1, x_74); +x_81 = lean_ctor_get(x_77, 0); +lean_inc(x_81); +lean_dec(x_77); +x_82 = lean_string_validate_utf8(x_81); +if (x_82 == 0) +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_81); +x_83 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_84 = l_panic___at_String_fromUTF8_x21___spec__1(x_83); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_72); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_80); +if (lean_is_scalar(x_79)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_79; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_78); +return x_87; +} +else +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_88 = lean_string_from_utf8(x_81); +lean_dec(x_81); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_72); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_80); +if (lean_is_scalar(x_79)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_79; +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_78); +return x_91; +} +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +lean_dec(x_75); +lean_dec(x_73); +lean_dec(x_72); +x_92 = lean_ctor_get(x_76, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_76, 1); +lean_inc(x_93); +if (lean_is_exclusive(x_76)) { + lean_ctor_release(x_76, 0); + lean_ctor_release(x_76, 1); + x_94 = x_76; +} else { + lean_dec_ref(x_76); + x_94 = lean_box(0); +} +if (lean_is_scalar(x_94)) { + x_95 = lean_alloc_ctor(1, 2, 0); +} else { + x_95 = x_94; +} +lean_ctor_set(x_95, 0, x_92); +lean_ctor_set(x_95, 1, x_93); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_13); +x_96 = !lean_is_exclusive(x_18); +if (x_96 == 0) +{ +lean_object* x_97; uint8_t x_98; +x_97 = lean_ctor_get(x_18, 0); +lean_dec(x_97); +x_98 = !lean_is_exclusive(x_19); +if (x_98 == 0) +{ +return x_18; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_19, 0); +x_100 = lean_ctor_get(x_19, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_19); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_18, 0, x_101); +return x_18; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_102 = lean_ctor_get(x_18, 1); +lean_inc(x_102); +lean_dec(x_18); +x_103 = lean_ctor_get(x_19, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_19, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_105 = x_19; +} else { + lean_dec_ref(x_19); + x_105 = lean_box(0); +} +if (lean_is_scalar(x_105)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_105; +} +lean_ctor_set(x_106, 0, x_103); +lean_ctor_set(x_106, 1, x_104); +x_107 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_102); +return x_107; +} +} +} +else +{ +uint8_t x_108; +lean_dec(x_13); +x_108 = !lean_is_exclusive(x_18); +if (x_108 == 0) +{ +return x_18; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_109 = lean_ctor_get(x_18, 0); +x_110 = lean_ctor_get(x_18, 1); +lean_inc(x_110); +lean_inc(x_109); +lean_dec(x_18); +x_111 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +return x_111; +} +} +} +else +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_inc(x_16); +x_112 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__10___rarg), 5, 2); +lean_closure_set(x_112, 0, x_16); +lean_closure_set(x_112, 1, x_1); +x_113 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__11___rarg), 5, 2); +lean_closure_set(x_113, 0, x_16); +lean_closure_set(x_113, 1, x_112); +x_114 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__12___rarg(x_15, x_113, x_3, x_4, x_14); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +if (lean_obj_tag(x_115) == 0) +{ +lean_object* x_116; lean_object* x_117; uint8_t x_118; +x_116 = lean_ctor_get(x_115, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_114, 1); +lean_inc(x_117); +lean_dec(x_114); +x_118 = !lean_is_exclusive(x_115); +if (x_118 == 0) +{ +lean_object* x_119; lean_object* x_120; uint8_t x_121; +x_119 = lean_ctor_get(x_115, 0); +x_120 = lean_ctor_get(x_115, 1); +lean_dec(x_120); +x_121 = !lean_is_exclusive(x_116); +if (x_121 == 0) +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_116, 0); +x_123 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_123) == 0) +{ +uint8_t x_124; +x_124 = !lean_is_exclusive(x_123); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; uint8_t x_127; +x_125 = lean_ctor_get(x_123, 0); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +lean_dec(x_125); +x_127 = lean_string_validate_utf8(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; +lean_dec(x_126); +x_128 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_129 = l_panic___at_String_fromUTF8_x21___spec__1(x_128); +x_130 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_119); +lean_ctor_set(x_115, 0, x_130); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +else +{ +lean_object* x_131; lean_object* x_132; +x_131 = lean_string_from_utf8(x_126); +lean_dec(x_126); +x_132 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_119); +lean_ctor_set(x_115, 0, x_132); +lean_ctor_set(x_123, 0, x_115); +return x_123; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_133 = lean_ctor_get(x_123, 0); +x_134 = lean_ctor_get(x_123, 1); +lean_inc(x_134); +lean_inc(x_133); +lean_dec(x_123); +x_135 = lean_ctor_get(x_133, 0); +lean_inc(x_135); +lean_dec(x_133); +x_136 = lean_string_validate_utf8(x_135); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; +lean_dec(x_135); +x_137 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_138 = l_panic___at_String_fromUTF8_x21___spec__1(x_137); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_119); +lean_ctor_set(x_115, 0, x_139); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_115); +lean_ctor_set(x_140, 1, x_134); +return x_140; +} +else +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_string_from_utf8(x_135); +lean_dec(x_135); +x_142 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_119); +lean_ctor_set(x_115, 0, x_142); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_115); +lean_ctor_set(x_143, 1, x_134); +return x_143; +} +} +} +else +{ +uint8_t x_144; +lean_free_object(x_116); +lean_dec(x_122); +lean_free_object(x_115); +lean_dec(x_119); +x_144 = !lean_is_exclusive(x_123); +if (x_144 == 0) +{ +return x_123; +} +else +{ +lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_145 = lean_ctor_get(x_123, 0); +x_146 = lean_ctor_get(x_123, 1); +lean_inc(x_146); +lean_inc(x_145); +lean_dec(x_123); +x_147 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_147, 0, x_145); +lean_ctor_set(x_147, 1, x_146); +return x_147; +} +} +} +else +{ +lean_object* x_148; uint8_t x_149; lean_object* x_150; +x_148 = lean_ctor_get(x_116, 0); +x_149 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +lean_inc(x_148); +lean_dec(x_116); +x_150 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_150) == 0) +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; uint8_t x_156; +x_151 = lean_ctor_get(x_150, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_150, 1); +lean_inc(x_152); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_153 = x_150; +} else { + lean_dec_ref(x_150); + x_153 = lean_box(0); +} +x_154 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_154, 0, x_148); +lean_ctor_set_uint8(x_154, sizeof(void*)*1, x_149); +x_155 = lean_ctor_get(x_151, 0); +lean_inc(x_155); +lean_dec(x_151); +x_156 = lean_string_validate_utf8(x_155); +if (x_156 == 0) +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; +lean_dec(x_155); +x_157 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_158 = l_panic___at_String_fromUTF8_x21___spec__1(x_157); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_159); +if (lean_is_scalar(x_153)) { + x_160 = lean_alloc_ctor(0, 2, 0); +} else { + x_160 = x_153; +} +lean_ctor_set(x_160, 0, x_115); +lean_ctor_set(x_160, 1, x_152); +return x_160; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_string_from_utf8(x_155); +lean_dec(x_155); +x_162 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_162, 0, x_161); +lean_ctor_set(x_162, 1, x_119); +lean_ctor_set(x_115, 1, x_154); +lean_ctor_set(x_115, 0, x_162); +if (lean_is_scalar(x_153)) { + x_163 = lean_alloc_ctor(0, 2, 0); +} else { + x_163 = x_153; +} +lean_ctor_set(x_163, 0, x_115); +lean_ctor_set(x_163, 1, x_152); +return x_163; +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_148); +lean_free_object(x_115); +lean_dec(x_119); +x_164 = lean_ctor_get(x_150, 0); +lean_inc(x_164); +x_165 = lean_ctor_get(x_150, 1); +lean_inc(x_165); +if (lean_is_exclusive(x_150)) { + lean_ctor_release(x_150, 0); + lean_ctor_release(x_150, 1); + x_166 = x_150; +} else { + lean_dec_ref(x_150); + x_166 = lean_box(0); +} +if (lean_is_scalar(x_166)) { + x_167 = lean_alloc_ctor(1, 2, 0); +} else { + x_167 = x_166; +} +lean_ctor_set(x_167, 0, x_164); +lean_ctor_set(x_167, 1, x_165); +return x_167; +} +} +} +else +{ +lean_object* x_168; lean_object* x_169; uint8_t x_170; lean_object* x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_115, 0); +lean_inc(x_168); +lean_dec(x_115); +x_169 = lean_ctor_get(x_116, 0); +lean_inc(x_169); +x_170 = lean_ctor_get_uint8(x_116, sizeof(void*)*1); +if (lean_is_exclusive(x_116)) { + lean_ctor_release(x_116, 0); + x_171 = x_116; +} else { + lean_dec_ref(x_116); + x_171 = lean_box(0); +} +x_172 = lean_st_ref_get(x_13, x_117); +lean_dec(x_13); +if (lean_obj_tag(x_172) == 0) +{ +lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_176 = lean_alloc_ctor(0, 1, 1); +} else { + x_176 = x_171; +} +lean_ctor_set(x_176, 0, x_169); +lean_ctor_set_uint8(x_176, sizeof(void*)*1, x_170); +x_177 = lean_ctor_get(x_173, 0); +lean_inc(x_177); +lean_dec(x_173); +x_178 = lean_string_validate_utf8(x_177); +if (x_178 == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_177); +x_179 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_180 = l_panic___at_String_fromUTF8_x21___spec__1(x_179); +x_181 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_181, 0, x_180); +lean_ctor_set(x_181, 1, x_168); +x_182 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_176); +if (lean_is_scalar(x_175)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_175; +} +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_174); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_184 = lean_string_from_utf8(x_177); +lean_dec(x_177); +x_185 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_185, 0, x_184); +lean_ctor_set(x_185, 1, x_168); +x_186 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_186, 0, x_185); +lean_ctor_set(x_186, 1, x_176); +if (lean_is_scalar(x_175)) { + x_187 = lean_alloc_ctor(0, 2, 0); +} else { + x_187 = x_175; +} +lean_ctor_set(x_187, 0, x_186); +lean_ctor_set(x_187, 1, x_174); +return x_187; +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_168); +x_188 = lean_ctor_get(x_172, 0); +lean_inc(x_188); +x_189 = lean_ctor_get(x_172, 1); +lean_inc(x_189); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_190 = x_172; +} else { + lean_dec_ref(x_172); + x_190 = lean_box(0); +} +if (lean_is_scalar(x_190)) { + x_191 = lean_alloc_ctor(1, 2, 0); +} else { + x_191 = x_190; +} +lean_ctor_set(x_191, 0, x_188); +lean_ctor_set(x_191, 1, x_189); +return x_191; +} +} +} +else +{ +uint8_t x_192; +lean_dec(x_13); +x_192 = !lean_is_exclusive(x_114); +if (x_192 == 0) +{ +lean_object* x_193; uint8_t x_194; +x_193 = lean_ctor_get(x_114, 0); +lean_dec(x_193); +x_194 = !lean_is_exclusive(x_115); +if (x_194 == 0) +{ +return x_114; +} +else +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_195 = lean_ctor_get(x_115, 0); +x_196 = lean_ctor_get(x_115, 1); +lean_inc(x_196); +lean_inc(x_195); +lean_dec(x_115); +x_197 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_197, 0, x_195); +lean_ctor_set(x_197, 1, x_196); +lean_ctor_set(x_114, 0, x_197); +return x_114; +} +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_198 = lean_ctor_get(x_114, 1); +lean_inc(x_198); +lean_dec(x_114); +x_199 = lean_ctor_get(x_115, 0); +lean_inc(x_199); +x_200 = lean_ctor_get(x_115, 1); +lean_inc(x_200); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_201 = x_115; +} else { + lean_dec_ref(x_115); + x_201 = lean_box(0); +} +if (lean_is_scalar(x_201)) { + x_202 = lean_alloc_ctor(1, 2, 0); +} else { + x_202 = x_201; +} +lean_ctor_set(x_202, 0, x_199); +lean_ctor_set(x_202, 1, x_200); +x_203 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_198); +return x_203; +} +} +} +else +{ +uint8_t x_204; +lean_dec(x_13); +x_204 = !lean_is_exclusive(x_114); +if (x_204 == 0) +{ +return x_114; +} +else +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; +x_205 = lean_ctor_get(x_114, 0); +x_206 = lean_ctor_get(x_114, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_114); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set(x_207, 1, x_206); +return x_207; +} +} +} +} +else +{ +uint8_t x_208; +lean_dec(x_10); +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_208 = !lean_is_exclusive(x_12); +if (x_208 == 0) +{ +return x_12; +} +else +{ +lean_object* x_209; lean_object* x_210; lean_object* x_211; +x_209 = lean_ctor_get(x_12, 0); +x_210 = lean_ctor_get(x_12, 1); +lean_inc(x_210); +lean_inc(x_209); +lean_dec(x_12); +x_211 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +return x_211; +} +} +} +else +{ +uint8_t x_212; +lean_free_object(x_4); +lean_dec(x_7); +lean_dec(x_3); +lean_dec(x_1); +x_212 = !lean_is_exclusive(x_9); +if (x_212 == 0) +{ +return x_9; +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_213 = lean_ctor_get(x_9, 0); +x_214 = lean_ctor_get(x_9, 1); +lean_inc(x_214); +lean_inc(x_213); +lean_dec(x_9); +x_215 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_215, 0, x_213); +lean_ctor_set(x_215, 1, x_214); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get_uint8(x_4, sizeof(void*)*1); +lean_inc(x_216); +lean_dec(x_4); +x_218 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1; +x_219 = lean_st_mk_ref(x_218, x_5); +if (lean_obj_tag(x_219) == 0) +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; +x_220 = lean_ctor_get(x_219, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_219, 1); +lean_inc(x_221); +lean_dec(x_219); +x_222 = lean_st_mk_ref(x_218, x_221); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_222, 0); +lean_inc(x_223); +x_224 = lean_ctor_get(x_222, 1); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_225, 0, x_216); +lean_ctor_set_uint8(x_225, sizeof(void*)*1, x_217); +x_226 = l_IO_FS_Stream_ofBuffer(x_220); +lean_inc(x_223); +x_227 = l_IO_FS_Stream_ofBuffer(x_223); +if (x_2 == 0) +{ +lean_object* x_228; lean_object* x_229; +x_228 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__8___rarg), 5, 2); +lean_closure_set(x_228, 0, x_227); +lean_closure_set(x_228, 1, x_1); +x_229 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__9___rarg(x_226, x_228, x_3, x_225, x_224); +if (lean_obj_tag(x_229) == 0) +{ +lean_object* x_230; +x_230 = lean_ctor_get(x_229, 0); +lean_inc(x_230); +if (lean_obj_tag(x_230) == 0) +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; lean_object* x_238; +x_231 = lean_ctor_get(x_230, 1); +lean_inc(x_231); +x_232 = lean_ctor_get(x_229, 1); +lean_inc(x_232); +lean_dec(x_229); +x_233 = lean_ctor_get(x_230, 0); +lean_inc(x_233); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_234 = x_230; +} else { + lean_dec_ref(x_230); + x_234 = lean_box(0); +} +x_235 = lean_ctor_get(x_231, 0); +lean_inc(x_235); +x_236 = lean_ctor_get_uint8(x_231, sizeof(void*)*1); +if (lean_is_exclusive(x_231)) { + lean_ctor_release(x_231, 0); + x_237 = x_231; +} else { + lean_dec_ref(x_231); + x_237 = lean_box(0); +} +x_238 = lean_st_ref_get(x_223, x_232); +lean_dec(x_223); +if (lean_obj_tag(x_238) == 0) +{ +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; +x_239 = lean_ctor_get(x_238, 0); +lean_inc(x_239); +x_240 = lean_ctor_get(x_238, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_241 = x_238; +} else { + lean_dec_ref(x_238); + x_241 = lean_box(0); +} +if (lean_is_scalar(x_237)) { + x_242 = lean_alloc_ctor(0, 1, 1); +} else { + x_242 = x_237; +} +lean_ctor_set(x_242, 0, x_235); +lean_ctor_set_uint8(x_242, sizeof(void*)*1, x_236); +x_243 = lean_ctor_get(x_239, 0); +lean_inc(x_243); +lean_dec(x_239); +x_244 = lean_string_validate_utf8(x_243); +if (x_244 == 0) +{ +lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +lean_dec(x_243); +x_245 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_246 = l_panic___at_String_fromUTF8_x21___spec__1(x_245); +x_247 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_233); +if (lean_is_scalar(x_234)) { + x_248 = lean_alloc_ctor(0, 2, 0); +} else { + x_248 = x_234; +} +lean_ctor_set(x_248, 0, x_247); +lean_ctor_set(x_248, 1, x_242); +if (lean_is_scalar(x_241)) { + x_249 = lean_alloc_ctor(0, 2, 0); +} else { + x_249 = x_241; +} +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_240); +return x_249; +} +else +{ +lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; +x_250 = lean_string_from_utf8(x_243); +lean_dec(x_243); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_233); +if (lean_is_scalar(x_234)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_234; +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_242); +if (lean_is_scalar(x_241)) { + x_253 = lean_alloc_ctor(0, 2, 0); +} else { + x_253 = x_241; +} +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_240); +return x_253; +} +} +else +{ +lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_237); +lean_dec(x_235); +lean_dec(x_234); +lean_dec(x_233); +x_254 = lean_ctor_get(x_238, 0); +lean_inc(x_254); +x_255 = lean_ctor_get(x_238, 1); +lean_inc(x_255); +if (lean_is_exclusive(x_238)) { + lean_ctor_release(x_238, 0); + lean_ctor_release(x_238, 1); + x_256 = x_238; +} else { + lean_dec_ref(x_238); + x_256 = lean_box(0); +} +if (lean_is_scalar(x_256)) { + x_257 = lean_alloc_ctor(1, 2, 0); +} else { + x_257 = x_256; +} +lean_ctor_set(x_257, 0, x_254); +lean_ctor_set(x_257, 1, x_255); +return x_257; +} +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_223); +x_258 = lean_ctor_get(x_229, 1); +lean_inc(x_258); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_259 = x_229; +} else { + lean_dec_ref(x_229); + x_259 = lean_box(0); +} +x_260 = lean_ctor_get(x_230, 0); +lean_inc(x_260); +x_261 = lean_ctor_get(x_230, 1); +lean_inc(x_261); +if (lean_is_exclusive(x_230)) { + lean_ctor_release(x_230, 0); + lean_ctor_release(x_230, 1); + x_262 = x_230; +} else { + lean_dec_ref(x_230); + x_262 = lean_box(0); +} +if (lean_is_scalar(x_262)) { + x_263 = lean_alloc_ctor(1, 2, 0); +} else { + x_263 = x_262; +} +lean_ctor_set(x_263, 0, x_260); +lean_ctor_set(x_263, 1, x_261); +if (lean_is_scalar(x_259)) { + x_264 = lean_alloc_ctor(0, 2, 0); +} else { + x_264 = x_259; +} +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_258); +return x_264; +} +} +else +{ +lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; +lean_dec(x_223); +x_265 = lean_ctor_get(x_229, 0); +lean_inc(x_265); +x_266 = lean_ctor_get(x_229, 1); +lean_inc(x_266); +if (lean_is_exclusive(x_229)) { + lean_ctor_release(x_229, 0); + lean_ctor_release(x_229, 1); + x_267 = x_229; +} else { + lean_dec_ref(x_229); + x_267 = lean_box(0); +} +if (lean_is_scalar(x_267)) { + x_268 = lean_alloc_ctor(1, 2, 0); +} else { + x_268 = x_267; +} +lean_ctor_set(x_268, 0, x_265); +lean_ctor_set(x_268, 1, x_266); +return x_268; +} +} +else +{ +lean_object* x_269; lean_object* x_270; lean_object* x_271; +lean_inc(x_227); +x_269 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Package_afterReleaseSync___spec__10___rarg), 5, 2); +lean_closure_set(x_269, 0, x_227); +lean_closure_set(x_269, 1, x_1); +x_270 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Package_afterReleaseSync___spec__11___rarg), 5, 2); +lean_closure_set(x_270, 0, x_227); +lean_closure_set(x_270, 1, x_269); +x_271 = l_IO_withStdin___at_Lake_Package_afterReleaseSync___spec__12___rarg(x_226, x_270, x_3, x_225, x_224); +if (lean_obj_tag(x_271) == 0) +{ +lean_object* x_272; +x_272 = lean_ctor_get(x_271, 0); +lean_inc(x_272); +if (lean_obj_tag(x_272) == 0) +{ +lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; uint8_t x_278; lean_object* x_279; lean_object* x_280; +x_273 = lean_ctor_get(x_272, 1); +lean_inc(x_273); +x_274 = lean_ctor_get(x_271, 1); +lean_inc(x_274); +lean_dec(x_271); +x_275 = lean_ctor_get(x_272, 0); +lean_inc(x_275); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_276 = x_272; +} else { + lean_dec_ref(x_272); + x_276 = lean_box(0); +} +x_277 = lean_ctor_get(x_273, 0); +lean_inc(x_277); +x_278 = lean_ctor_get_uint8(x_273, sizeof(void*)*1); +if (lean_is_exclusive(x_273)) { + lean_ctor_release(x_273, 0); + x_279 = x_273; +} else { + lean_dec_ref(x_273); + x_279 = lean_box(0); +} +x_280 = lean_st_ref_get(x_223, x_274); +lean_dec(x_223); +if (lean_obj_tag(x_280) == 0) +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; +x_281 = lean_ctor_get(x_280, 0); +lean_inc(x_281); +x_282 = lean_ctor_get(x_280, 1); +lean_inc(x_282); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_283 = x_280; +} else { + lean_dec_ref(x_280); + x_283 = lean_box(0); +} +if (lean_is_scalar(x_279)) { + x_284 = lean_alloc_ctor(0, 1, 1); +} else { + x_284 = x_279; +} +lean_ctor_set(x_284, 0, x_277); +lean_ctor_set_uint8(x_284, sizeof(void*)*1, x_278); +x_285 = lean_ctor_get(x_281, 0); +lean_inc(x_285); +lean_dec(x_281); +x_286 = lean_string_validate_utf8(x_285); +if (x_286 == 0) +{ +lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; +lean_dec(x_285); +x_287 = l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5; +x_288 = l_panic___at_String_fromUTF8_x21___spec__1(x_287); +x_289 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_275); +if (lean_is_scalar(x_276)) { + x_290 = lean_alloc_ctor(0, 2, 0); +} else { + x_290 = x_276; +} +lean_ctor_set(x_290, 0, x_289); +lean_ctor_set(x_290, 1, x_284); +if (lean_is_scalar(x_283)) { + x_291 = lean_alloc_ctor(0, 2, 0); +} else { + x_291 = x_283; +} +lean_ctor_set(x_291, 0, x_290); +lean_ctor_set(x_291, 1, x_282); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; +x_292 = lean_string_from_utf8(x_285); +lean_dec(x_285); +x_293 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_293, 0, x_292); +lean_ctor_set(x_293, 1, x_275); +if (lean_is_scalar(x_276)) { + x_294 = lean_alloc_ctor(0, 2, 0); +} else { + x_294 = x_276; +} +lean_ctor_set(x_294, 0, x_293); +lean_ctor_set(x_294, 1, x_284); +if (lean_is_scalar(x_283)) { + x_295 = lean_alloc_ctor(0, 2, 0); +} else { + x_295 = x_283; +} +lean_ctor_set(x_295, 0, x_294); +lean_ctor_set(x_295, 1, x_282); +return x_295; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +lean_dec(x_279); +lean_dec(x_277); +lean_dec(x_276); +lean_dec(x_275); +x_296 = lean_ctor_get(x_280, 0); +lean_inc(x_296); +x_297 = lean_ctor_get(x_280, 1); +lean_inc(x_297); +if (lean_is_exclusive(x_280)) { + lean_ctor_release(x_280, 0); + lean_ctor_release(x_280, 1); + x_298 = x_280; +} else { + lean_dec_ref(x_280); + x_298 = lean_box(0); +} +if (lean_is_scalar(x_298)) { + x_299 = lean_alloc_ctor(1, 2, 0); +} else { + x_299 = x_298; +} +lean_ctor_set(x_299, 0, x_296); +lean_ctor_set(x_299, 1, x_297); +return x_299; +} +} +else +{ +lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; +lean_dec(x_223); +x_300 = lean_ctor_get(x_271, 1); +lean_inc(x_300); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_301 = x_271; +} else { + lean_dec_ref(x_271); + x_301 = lean_box(0); +} +x_302 = lean_ctor_get(x_272, 0); +lean_inc(x_302); +x_303 = lean_ctor_get(x_272, 1); +lean_inc(x_303); +if (lean_is_exclusive(x_272)) { + lean_ctor_release(x_272, 0); + lean_ctor_release(x_272, 1); + x_304 = x_272; +} else { + lean_dec_ref(x_272); + x_304 = lean_box(0); +} +if (lean_is_scalar(x_304)) { + x_305 = lean_alloc_ctor(1, 2, 0); +} else { + x_305 = x_304; +} +lean_ctor_set(x_305, 0, x_302); +lean_ctor_set(x_305, 1, x_303); +if (lean_is_scalar(x_301)) { + x_306 = lean_alloc_ctor(0, 2, 0); +} else { + x_306 = x_301; +} +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_300); +return x_306; +} +} +else +{ +lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; +lean_dec(x_223); +x_307 = lean_ctor_get(x_271, 0); +lean_inc(x_307); +x_308 = lean_ctor_get(x_271, 1); +lean_inc(x_308); +if (lean_is_exclusive(x_271)) { + lean_ctor_release(x_271, 0); + lean_ctor_release(x_271, 1); + x_309 = x_271; +} else { + lean_dec_ref(x_271); + x_309 = lean_box(0); +} +if (lean_is_scalar(x_309)) { + x_310 = lean_alloc_ctor(1, 2, 0); +} else { + x_310 = x_309; +} +lean_ctor_set(x_310, 0, x_307); +lean_ctor_set(x_310, 1, x_308); +return x_310; +} +} +} +else +{ +lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; +lean_dec(x_220); +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_311 = lean_ctor_get(x_222, 0); +lean_inc(x_311); +x_312 = lean_ctor_get(x_222, 1); +lean_inc(x_312); +if (lean_is_exclusive(x_222)) { + lean_ctor_release(x_222, 0); + lean_ctor_release(x_222, 1); + x_313 = x_222; +} else { + lean_dec_ref(x_222); + x_313 = lean_box(0); +} +if (lean_is_scalar(x_313)) { + x_314 = lean_alloc_ctor(1, 2, 0); +} else { + x_314 = x_313; +} +lean_ctor_set(x_314, 0, x_311); +lean_ctor_set(x_314, 1, x_312); +return x_314; +} +} +else +{ +lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; +lean_dec(x_216); +lean_dec(x_3); +lean_dec(x_1); +x_315 = lean_ctor_get(x_219, 0); +lean_inc(x_315); +x_316 = lean_ctor_get(x_219, 1); +lean_inc(x_316); +if (lean_is_exclusive(x_219)) { + lean_ctor_release(x_219, 0); + lean_ctor_release(x_219, 1); + x_317 = x_219; +} else { + lean_dec_ref(x_219); + x_317 = lean_box(0); +} +if (lean_is_scalar(x_317)) { + x_318 = lean_alloc_ctor(1, 2, 0); +} else { + x_318 = x_317; +} +lean_ctor_set(x_318, 0, x_315); +lean_ctor_set(x_318, 1, x_316); +return x_318; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; lean_object* x_6; +x_5 = 1; +lean_inc(x_2); +x_6 = l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1___rarg(x_1, x_5, x_2, x_3, x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_6, 1); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_ctor_get(x_8, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_8, 1); +lean_inc(x_12); +lean_dec(x_8); +x_13 = l_String_isEmpty(x_11); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; uint8_t x_20; +x_14 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1; +x_15 = lean_string_append(x_14, x_11); +lean_dec(x_11); +x_16 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_17 = lean_string_append(x_15, x_16); +x_18 = 1; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = !lean_is_exclusive(x_10); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_10, 0); +x_22 = lean_array_push(x_21, x_19); +lean_ctor_set(x_10, 0, x_22); +x_23 = lean_box(0); +x_24 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_12, x_23, x_2, x_10, x_9); +lean_dec(x_2); +return x_24; +} +else +{ +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_25 = lean_ctor_get(x_10, 0); +x_26 = lean_ctor_get_uint8(x_10, sizeof(void*)*1); +lean_inc(x_25); +lean_dec(x_10); +x_27 = lean_array_push(x_25, x_19); +x_28 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set_uint8(x_28, sizeof(void*)*1, x_26); +x_29 = lean_box(0); +x_30 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_12, x_29, x_2, x_28, x_9); +lean_dec(x_2); +return x_30; +} +} +else +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_11); +x_31 = lean_box(0); +x_32 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_12, x_31, x_2, x_10, x_9); +lean_dec(x_2); +return x_32; +} +} +else +{ +uint8_t x_33; +lean_dec(x_2); +x_33 = !lean_is_exclusive(x_6); +if (x_33 == 0) +{ +lean_object* x_34; uint8_t x_35; +x_34 = lean_ctor_get(x_6, 0); +lean_dec(x_34); +x_35 = !lean_is_exclusive(x_7); +if (x_35 == 0) +{ +return x_6; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_7, 0); +x_37 = lean_ctor_get(x_7, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_7); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +lean_ctor_set(x_6, 0, x_38); +return x_6; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_39 = lean_ctor_get(x_6, 1); +lean_inc(x_39); +lean_dec(x_6); +x_40 = lean_ctor_get(x_7, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_7, 1); +lean_inc(x_41); +if (lean_is_exclusive(x_7)) { + lean_ctor_release(x_7, 0); + lean_ctor_release(x_7, 1); + x_42 = x_7; +} else { + lean_dec_ref(x_7); + x_42 = lean_box(0); +} +if (lean_is_scalar(x_42)) { + x_43 = lean_alloc_ctor(1, 2, 0); +} else { + x_43 = x_42; +} +lean_ctor_set(x_43, 0, x_40); +lean_ctor_set(x_43, 1, x_41); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_39); +return x_44; +} +} +} +else +{ +uint8_t x_45; +lean_dec(x_2); +x_45 = !lean_is_exclusive(x_6); +if (x_45 == 0) +{ +return x_6; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_6, 0); +x_47 = lean_ctor_get(x_6, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_6); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +return x_48; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_3) == 0) +{ +lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = 1; +lean_inc(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7___rarg(x_1, x_6, x_2, x_5, x_4); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_9 = lean_ctor_get(x_8, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_7, 1); +lean_inc(x_10); +lean_dec(x_7); +x_11 = lean_ctor_get(x_8, 1); +lean_inc(x_11); +lean_dec(x_8); +x_12 = lean_ctor_get(x_9, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = l_String_isEmpty(x_12); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; uint8_t x_21; +x_15 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1; +x_16 = lean_string_append(x_15, x_12); +lean_dec(x_12); +x_17 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_18 = lean_string_append(x_16, x_17); +x_19 = 1; +x_20 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set_uint8(x_20, sizeof(void*)*1, x_19); +x_21 = !lean_is_exclusive(x_11); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_11, 0); +x_23 = lean_array_push(x_22, x_20); +lean_ctor_set(x_11, 0, x_23); +x_24 = lean_box(0); +x_25 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_13, x_24, x_2, x_11, x_10); +lean_dec(x_2); +return x_25; +} +else +{ +lean_object* x_26; uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_26 = lean_ctor_get(x_11, 0); +x_27 = lean_ctor_get_uint8(x_11, sizeof(void*)*1); +lean_inc(x_26); +lean_dec(x_11); +x_28 = lean_array_push(x_26, x_20); +x_29 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set_uint8(x_29, sizeof(void*)*1, x_27); +x_30 = lean_box(0); +x_31 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_13, x_30, x_2, x_29, x_10); +lean_dec(x_2); +return x_31; +} +} +else +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_12); +x_32 = lean_box(0); +x_33 = l_Lake_Package_recBuildExtraDepTargets___lambda__2(x_13, x_32, x_2, x_11, x_10); +lean_dec(x_2); +return x_33; +} +} +else +{ +uint8_t x_34; +lean_dec(x_2); +x_34 = !lean_is_exclusive(x_7); +if (x_34 == 0) +{ +lean_object* x_35; uint8_t x_36; +x_35 = lean_ctor_get(x_7, 0); +lean_dec(x_35); +x_36 = !lean_is_exclusive(x_8); +if (x_36 == 0) +{ +return x_7; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_8, 0); +x_38 = lean_ctor_get(x_8, 1); +lean_inc(x_38); +lean_inc(x_37); +lean_dec(x_8); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +lean_ctor_set(x_7, 0, x_39); +return x_7; +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_40 = lean_ctor_get(x_7, 1); +lean_inc(x_40); +lean_dec(x_7); +x_41 = lean_ctor_get(x_8, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_8, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + lean_ctor_release(x_8, 1); + x_43 = x_8; +} else { + lean_dec_ref(x_8); + x_43 = lean_box(0); +} +if (lean_is_scalar(x_43)) { + x_44 = lean_alloc_ctor(1, 2, 0); +} else { + x_44 = x_43; +} +lean_ctor_set(x_44, 0, x_41); +lean_ctor_set(x_44, 1, x_42); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_40); +return x_45; +} +} +} +else +{ +uint8_t x_46; +lean_dec(x_2); +x_46 = !lean_is_exclusive(x_7); +if (x_46 == 0) +{ +return x_7; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_7, 0); +x_48 = lean_ctor_get(x_7, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_7); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +return x_49; +} +} +} +else +{ +uint8_t x_50; +lean_dec(x_2); +lean_dec(x_1); +x_50 = !lean_is_exclusive(x_3); +if (x_50 == 0) +{ +lean_object* x_51; +x_51 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_51, 0, x_3); +lean_ctor_set(x_51, 1, x_4); +return x_51; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_3, 0); +x_53 = lean_ctor_get(x_3, 1); +lean_inc(x_53); +lean_inc(x_52); +lean_dec(x_3); +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set(x_54, 1, x_53); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_4); +return x_55; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_1, 2); +lean_inc(x_32); +x_33 = lean_ctor_get_uint8(x_32, sizeof(void*)*21 + 1); +if (x_33 == 0) +{ +lean_object* x_34; +lean_dec(x_32); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_34 = lean_box(0); +x_9 = x_34; +goto block_31; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; uint8_t x_41; +x_35 = lean_ctor_get(x_5, 1); +lean_inc(x_35); +x_36 = lean_ctor_get(x_35, 0); +lean_inc(x_36); +lean_dec(x_35); +x_37 = lean_ctor_get(x_32, 2); +lean_inc(x_37); +lean_dec(x_32); +x_38 = lean_ctor_get(x_36, 2); +lean_inc(x_38); +lean_dec(x_36); +x_39 = lean_ctor_get(x_38, 2); +lean_inc(x_39); +lean_dec(x_38); +x_40 = lean_name_eq(x_37, x_39); +lean_dec(x_39); +lean_dec(x_37); +x_41 = l_instDecidableNot___rarg(x_40); +if (x_41 == 0) +{ +lean_object* x_42; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_42 = lean_box(0); +x_9 = x_42; +goto block_31; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = l_Lake_Package_releaseFacetConfig___closed__2; +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_1); +lean_ctor_set(x_44, 1, x_43); +lean_inc(x_5); +x_45 = lean_apply_6(x_3, x_44, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_46, 0); +lean_inc(x_47); +if (lean_obj_tag(x_47) == 0) +{ +lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_45, 1); +lean_inc(x_49); +lean_dec(x_45); +x_50 = !lean_is_exclusive(x_46); +if (x_50 == 0) +{ +lean_object* x_51; lean_object* x_52; uint8_t x_53; +x_51 = lean_ctor_get(x_46, 1); +x_52 = lean_ctor_get(x_46, 0); +lean_dec(x_52); +x_53 = !lean_is_exclusive(x_47); +if (x_53 == 0) +{ +lean_object* x_54; lean_object* x_55; uint8_t x_56; +x_54 = lean_ctor_get(x_47, 1); +x_55 = lean_ctor_get(x_47, 0); +lean_dec(x_55); +x_56 = !lean_is_exclusive(x_48); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; +x_57 = lean_ctor_get(x_48, 0); +x_58 = lean_ctor_get(x_48, 1); +x_59 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseSync___rarg___lambda__2), 4, 2); +lean_closure_set(x_59, 0, x_2); +lean_closure_set(x_59, 1, x_5); +x_60 = l_Task_Priority_default; +x_61 = 0; +x_62 = lean_io_map_task(x_59, x_57, x_60, x_61, x_49); +if (lean_obj_tag(x_62) == 0) +{ +uint8_t x_63; +x_63 = !lean_is_exclusive(x_62); +if (x_63 == 0) +{ +lean_object* x_64; +x_64 = lean_ctor_get(x_62, 0); +lean_ctor_set(x_48, 0, x_64); +lean_ctor_set(x_62, 0, x_46); +return x_62; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_ctor_get(x_62, 0); +x_66 = lean_ctor_get(x_62, 1); +lean_inc(x_66); +lean_inc(x_65); +lean_dec(x_62); +lean_ctor_set(x_48, 0, x_65); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_46); +lean_ctor_set(x_67, 1, x_66); +return x_67; +} +} +else +{ +uint8_t x_68; +lean_free_object(x_48); +lean_dec(x_58); +lean_free_object(x_47); +lean_dec(x_54); +lean_free_object(x_46); +lean_dec(x_51); +x_68 = !lean_is_exclusive(x_62); +if (x_68 == 0) +{ +return x_62; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_62, 0); +x_70 = lean_ctor_get(x_62, 1); +lean_inc(x_70); +lean_inc(x_69); +lean_dec(x_62); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_69); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; lean_object* x_77; +x_72 = lean_ctor_get(x_48, 0); +x_73 = lean_ctor_get(x_48, 1); +lean_inc(x_73); +lean_inc(x_72); +lean_dec(x_48); +x_74 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseSync___rarg___lambda__2), 4, 2); +lean_closure_set(x_74, 0, x_2); +lean_closure_set(x_74, 1, x_5); +x_75 = l_Task_Priority_default; +x_76 = 0; +x_77 = lean_io_map_task(x_74, x_72, x_75, x_76, x_49); +if (lean_obj_tag(x_77) == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_78 = lean_ctor_get(x_77, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_77, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_77)) { + lean_ctor_release(x_77, 0); + lean_ctor_release(x_77, 1); + x_80 = x_77; +} else { + lean_dec_ref(x_77); + x_80 = lean_box(0); +} +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_78); +lean_ctor_set(x_81, 1, x_73); +lean_ctor_set(x_47, 0, x_81); +if (lean_is_scalar(x_80)) { + x_82 = lean_alloc_ctor(0, 2, 0); +} else { + x_82 = x_80; +} +lean_ctor_set(x_82, 0, x_46); +lean_ctor_set(x_82, 1, x_79); +return x_82; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +lean_dec(x_73); +lean_free_object(x_47); +lean_dec(x_54); +lean_free_object(x_46); +lean_dec(x_51); +x_83 = lean_ctor_get(x_77, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_77, 1); +lean_inc(x_84); +if (lean_is_exclusive(x_77)) { + lean_ctor_release(x_77, 0); + lean_ctor_release(x_77, 1); + x_85 = x_77; +} else { + lean_dec_ref(x_77); + x_85 = lean_box(0); +} +if (lean_is_scalar(x_85)) { + x_86 = lean_alloc_ctor(1, 2, 0); +} else { + x_86 = x_85; +} +lean_ctor_set(x_86, 0, x_83); +lean_ctor_set(x_86, 1, x_84); +return x_86; +} +} +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; +x_87 = lean_ctor_get(x_47, 1); +lean_inc(x_87); +lean_dec(x_47); +x_88 = lean_ctor_get(x_48, 0); +lean_inc(x_88); +x_89 = lean_ctor_get(x_48, 1); +lean_inc(x_89); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_90 = x_48; +} else { + lean_dec_ref(x_48); + x_90 = lean_box(0); +} +x_91 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseSync___rarg___lambda__2), 4, 2); +lean_closure_set(x_91, 0, x_2); +lean_closure_set(x_91, 1, x_5); +x_92 = l_Task_Priority_default; +x_93 = 0; +x_94 = lean_io_map_task(x_91, x_88, x_92, x_93, x_49); +if (lean_obj_tag(x_94) == 0) +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_95 = lean_ctor_get(x_94, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_94, 1); +lean_inc(x_96); +if (lean_is_exclusive(x_94)) { + lean_ctor_release(x_94, 0); + lean_ctor_release(x_94, 1); + x_97 = x_94; +} else { + lean_dec_ref(x_94); + x_97 = lean_box(0); +} +if (lean_is_scalar(x_90)) { + x_98 = lean_alloc_ctor(0, 2, 0); +} else { + x_98 = x_90; +} +lean_ctor_set(x_98, 0, x_95); +lean_ctor_set(x_98, 1, x_89); +x_99 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_99, 0, x_98); +lean_ctor_set(x_99, 1, x_87); +lean_ctor_set(x_46, 0, x_99); +if (lean_is_scalar(x_97)) { + x_100 = lean_alloc_ctor(0, 2, 0); +} else { + x_100 = x_97; +} +lean_ctor_set(x_100, 0, x_46); +lean_ctor_set(x_100, 1, x_96); +return x_100; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +lean_dec(x_90); +lean_dec(x_89); +lean_dec(x_87); +lean_free_object(x_46); +lean_dec(x_51); +x_101 = lean_ctor_get(x_94, 0); +lean_inc(x_101); +x_102 = lean_ctor_get(x_94, 1); +lean_inc(x_102); +if (lean_is_exclusive(x_94)) { + lean_ctor_release(x_94, 0); + lean_ctor_release(x_94, 1); + x_103 = x_94; +} else { + lean_dec_ref(x_94); + x_103 = lean_box(0); +} +if (lean_is_scalar(x_103)) { + x_104 = lean_alloc_ctor(1, 2, 0); +} else { + x_104 = x_103; +} +lean_ctor_set(x_104, 0, x_101); +lean_ctor_set(x_104, 1, x_102); +return x_104; +} +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; +x_105 = lean_ctor_get(x_46, 1); +lean_inc(x_105); +lean_dec(x_46); +x_106 = lean_ctor_get(x_47, 1); +lean_inc(x_106); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_107 = x_47; +} else { + lean_dec_ref(x_47); + x_107 = lean_box(0); +} +x_108 = lean_ctor_get(x_48, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_48, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_48)) { + lean_ctor_release(x_48, 0); + lean_ctor_release(x_48, 1); + x_110 = x_48; +} else { + lean_dec_ref(x_48); + x_110 = lean_box(0); +} +x_111 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseSync___rarg___lambda__2), 4, 2); +lean_closure_set(x_111, 0, x_2); +lean_closure_set(x_111, 1, x_5); +x_112 = l_Task_Priority_default; +x_113 = 0; +x_114 = lean_io_map_task(x_111, x_108, x_112, x_113, x_49); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; +x_115 = lean_ctor_get(x_114, 0); +lean_inc(x_115); +x_116 = lean_ctor_get(x_114, 1); +lean_inc(x_116); +if (lean_is_exclusive(x_114)) { + lean_ctor_release(x_114, 0); + lean_ctor_release(x_114, 1); + x_117 = x_114; +} else { + lean_dec_ref(x_114); + x_117 = lean_box(0); +} +if (lean_is_scalar(x_110)) { + x_118 = lean_alloc_ctor(0, 2, 0); +} else { + x_118 = x_110; +} +lean_ctor_set(x_118, 0, x_115); +lean_ctor_set(x_118, 1, x_109); +if (lean_is_scalar(x_107)) { + x_119 = lean_alloc_ctor(0, 2, 0); +} else { + x_119 = x_107; +} +lean_ctor_set(x_119, 0, x_118); +lean_ctor_set(x_119, 1, x_106); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_105); +if (lean_is_scalar(x_117)) { + x_121 = lean_alloc_ctor(0, 2, 0); +} else { + x_121 = x_117; +} +lean_ctor_set(x_121, 0, x_120); +lean_ctor_set(x_121, 1, x_116); +return x_121; +} +else +{ +lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; +lean_dec(x_110); +lean_dec(x_109); +lean_dec(x_107); +lean_dec(x_106); +lean_dec(x_105); +x_122 = lean_ctor_get(x_114, 0); +lean_inc(x_122); +x_123 = lean_ctor_get(x_114, 1); +lean_inc(x_123); +if (lean_is_exclusive(x_114)) { + lean_ctor_release(x_114, 0); + lean_ctor_release(x_114, 1); + x_124 = x_114; +} else { + lean_dec_ref(x_114); + x_124 = lean_box(0); +} +if (lean_is_scalar(x_124)) { + x_125 = lean_alloc_ctor(1, 2, 0); +} else { + x_125 = x_124; +} +lean_ctor_set(x_125, 0, x_122); +lean_ctor_set(x_125, 1, x_123); +return x_125; +} +} +} +else +{ +uint8_t x_126; +lean_dec(x_5); +lean_dec(x_2); +x_126 = !lean_is_exclusive(x_45); +if (x_126 == 0) +{ +lean_object* x_127; uint8_t x_128; +x_127 = lean_ctor_get(x_45, 0); +lean_dec(x_127); +x_128 = !lean_is_exclusive(x_46); +if (x_128 == 0) +{ +lean_object* x_129; uint8_t x_130; +x_129 = lean_ctor_get(x_46, 0); +lean_dec(x_129); +x_130 = !lean_is_exclusive(x_47); +if (x_130 == 0) +{ +return x_45; +} +else +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; +x_131 = lean_ctor_get(x_47, 0); +x_132 = lean_ctor_get(x_47, 1); +lean_inc(x_132); +lean_inc(x_131); +lean_dec(x_47); +x_133 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_133, 0, x_131); +lean_ctor_set(x_133, 1, x_132); +lean_ctor_set(x_46, 0, x_133); +return x_45; +} +} +else +{ +lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_134 = lean_ctor_get(x_46, 1); +lean_inc(x_134); +lean_dec(x_46); +x_135 = lean_ctor_get(x_47, 0); +lean_inc(x_135); +x_136 = lean_ctor_get(x_47, 1); +lean_inc(x_136); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_137 = x_47; +} else { + lean_dec_ref(x_47); + x_137 = lean_box(0); +} +if (lean_is_scalar(x_137)) { + x_138 = lean_alloc_ctor(1, 2, 0); +} else { + x_138 = x_137; +} +lean_ctor_set(x_138, 0, x_135); +lean_ctor_set(x_138, 1, x_136); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_134); +lean_ctor_set(x_45, 0, x_139); +return x_45; +} +} +else +{ +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; +x_140 = lean_ctor_get(x_45, 1); +lean_inc(x_140); +lean_dec(x_45); +x_141 = lean_ctor_get(x_46, 1); +lean_inc(x_141); +if (lean_is_exclusive(x_46)) { + lean_ctor_release(x_46, 0); + lean_ctor_release(x_46, 1); + x_142 = x_46; +} else { + lean_dec_ref(x_46); + x_142 = lean_box(0); +} +x_143 = lean_ctor_get(x_47, 0); +lean_inc(x_143); +x_144 = lean_ctor_get(x_47, 1); +lean_inc(x_144); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_145 = x_47; +} else { + lean_dec_ref(x_47); + x_145 = lean_box(0); +} +if (lean_is_scalar(x_145)) { + x_146 = lean_alloc_ctor(1, 2, 0); +} else { + x_146 = x_145; +} +lean_ctor_set(x_146, 0, x_143); +lean_ctor_set(x_146, 1, x_144); +if (lean_is_scalar(x_142)) { + x_147 = lean_alloc_ctor(0, 2, 0); +} else { + x_147 = x_142; +} +lean_ctor_set(x_147, 0, x_146); +lean_ctor_set(x_147, 1, x_141); +x_148 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_148, 0, x_147); +lean_ctor_set(x_148, 1, x_140); +return x_148; +} +} +} +else +{ +uint8_t x_149; +lean_dec(x_5); +lean_dec(x_2); +x_149 = !lean_is_exclusive(x_45); +if (x_149 == 0) +{ +return x_45; +} +else +{ +lean_object* x_150; lean_object* x_151; lean_object* x_152; +x_150 = lean_ctor_get(x_45, 0); +x_151 = lean_ctor_get(x_45, 1); +lean_inc(x_151); +lean_inc(x_150); +lean_dec(x_45); +x_152 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set(x_152, 1, x_151); +return x_152; +} +} +} +} +block_31: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_9); +x_10 = l_Lake_Package_recBuildExtraDepTargets___closed__2; +x_11 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseSync___rarg___lambda__1), 4, 3); +lean_closure_set(x_11, 0, x_2); +lean_closure_set(x_11, 1, x_5); +lean_closure_set(x_11, 2, x_10); +x_12 = l_Task_Priority_default; +x_13 = lean_io_as_task(x_11, x_12, x_8); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_13); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_15 = lean_ctor_get(x_13, 0); +x_16 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_16); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_6); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_7); +lean_ctor_set(x_13, 0, x_19); +return x_13; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_20 = lean_ctor_get(x_13, 0); +x_21 = lean_ctor_get(x_13, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_13); +x_22 = l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2; +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_20); +lean_ctor_set(x_23, 1, x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_6); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_7); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_21); +return x_26; +} +} +else +{ +uint8_t x_27; +lean_dec(x_7); +lean_dec(x_6); +x_27 = !lean_is_exclusive(x_13); +if (x_27 == 0) +{ +return x_13; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_13, 0); +x_29 = lean_ctor_get(x_13, 1); +lean_inc(x_29); +lean_inc(x_28); +lean_dec(x_13); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +return x_30; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_afterReleaseSync(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Package_afterReleaseSync___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__1___rarg(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; lean_object* x_7; +x_6 = lean_unbox(x_2); +lean_dec(x_2); +x_7 = l_IO_FS_withIsolatedStreams___at_Lake_Package_afterReleaseSync___spec__7___rarg(x_1, x_6, x_3, x_4, x_5); +return x_7; +} +} +static lean_object* _init_l_Lake_initPackageFacetConfigs___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = lean_box(0); +x_2 = l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__2; +x_3 = l_Lake_Package_depsFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addPackageFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initPackageFacetConfigs___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initPackageFacetConfigs___closed__1; +x_2 = l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__2; +x_3 = l_Lake_Package_extraDepFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addPackageFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initPackageFacetConfigs___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initPackageFacetConfigs___closed__2; +x_2 = l_Lake_Package_recBuildExtraDepTargets___closed__8; +x_3 = l_Lake_Package_optReleaseFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addPackageFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initPackageFacetConfigs___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_initPackageFacetConfigs___closed__3; +x_2 = l_Lake_Package_releaseFacetConfig___closed__2; +x_3 = l_Lake_Package_releaseFacetConfig; +x_4 = l_Lean_RBNode_insert___at_Lake_Workspace_addPackageFacetConfig___spec__1(x_1, x_2, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_initPackageFacetConfigs() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_initPackageFacetConfigs___closed__4; +return x_1; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Git(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Sugar(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Common(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Targets(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Package(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Git(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Sugar(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Common(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Targets(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__1 = _init_l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__1(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__1); +l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__2 = _init_l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__2(); +lean_mark_persistent(l_Lake_OrdHashSet_insert___at_Lake_Package_recComputeDeps___spec__1___closed__2); +l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__1 = _init_l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__1(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__1); +l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__2 = _init_l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__2(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_Package_recComputeDeps___spec__11___closed__2); +l_Lake_Package_recComputeDeps___closed__1 = _init_l_Lake_Package_recComputeDeps___closed__1(); +lean_mark_persistent(l_Lake_Package_recComputeDeps___closed__1); +l_Lake_Package_depsFacetConfig___closed__1 = _init_l_Lake_Package_depsFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Package_depsFacetConfig___closed__1); +l_Lake_Package_depsFacetConfig___closed__2 = _init_l_Lake_Package_depsFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Package_depsFacetConfig___closed__2); +l_Lake_Package_depsFacetConfig = _init_l_Lake_Package_depsFacetConfig(); +lean_mark_persistent(l_Lake_Package_depsFacetConfig); +l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__1 = _init_l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__1(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__1); +l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__2 = _init_l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__2(); +lean_mark_persistent(l_Array_forInUnsafe_loop___at_Lake_Package_recBuildExtraDepTargets___spec__1___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__2 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__2(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__3 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__3(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__3); +l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__4 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__4(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__4); +l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Package_recBuildExtraDepTargets___spec__3___closed__5); +l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1 = _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__1); +l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2 = _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__2); +l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__3 = _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__3(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__3); +l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__4 = _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__4(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__4); +l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__5 = _init_l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__5(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___lambda__5___closed__5); +l_Lake_Package_recBuildExtraDepTargets___closed__1 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__1(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__1); +l_Lake_Package_recBuildExtraDepTargets___closed__2 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__2(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__2); +l_Lake_Package_recBuildExtraDepTargets___closed__3 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__3(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__3); +l_Lake_Package_recBuildExtraDepTargets___closed__4 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__4(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__4); +l_Lake_Package_recBuildExtraDepTargets___closed__5 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__5(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__5); +l_Lake_Package_recBuildExtraDepTargets___closed__6 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__6(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__6); +l_Lake_Package_recBuildExtraDepTargets___closed__7 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__7(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__7); +l_Lake_Package_recBuildExtraDepTargets___closed__8 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__8(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__8); +l_Lake_Package_recBuildExtraDepTargets___closed__9 = _init_l_Lake_Package_recBuildExtraDepTargets___closed__9(); +lean_mark_persistent(l_Lake_Package_recBuildExtraDepTargets___closed__9); +l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__1 = _init_l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__1(); +lean_mark_persistent(l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__1); +l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__2 = _init_l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__2(); +lean_mark_persistent(l_Functor_discard___at_Lake_Package_extraDepFacetConfig___spec__1___closed__2); +l_Lake_Package_extraDepFacetConfig___closed__1 = _init_l_Lake_Package_extraDepFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Package_extraDepFacetConfig___closed__1); +l_Lake_Package_extraDepFacetConfig___closed__2 = _init_l_Lake_Package_extraDepFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Package_extraDepFacetConfig___closed__2); +l_Lake_Package_extraDepFacetConfig___closed__3 = _init_l_Lake_Package_extraDepFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Package_extraDepFacetConfig___closed__3); +l_Lake_Package_extraDepFacetConfig___closed__4 = _init_l_Lake_Package_extraDepFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Package_extraDepFacetConfig___closed__4); +l_Lake_Package_extraDepFacetConfig = _init_l_Lake_Package_extraDepFacetConfig(); +lean_mark_persistent(l_Lake_Package_extraDepFacetConfig); +l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___closed__1 = _init_l_Lake_buildUnlessUpToDate_x3f___at_Lake_Package_fetchOptRelease___spec__1___lambda__2___closed__1(); +l_Lake_Package_fetchOptRelease___lambda__2___closed__1 = _init_l_Lake_Package_fetchOptRelease___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__2___closed__1); +l_Lake_Package_fetchOptRelease___lambda__3___closed__1 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__1(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__1); +l_Lake_Package_fetchOptRelease___lambda__3___closed__2 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__2(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__2); +l_Lake_Package_fetchOptRelease___lambda__3___closed__3 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__3(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__3); +l_Lake_Package_fetchOptRelease___lambda__3___closed__4 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__4(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__4); +l_Lake_Package_fetchOptRelease___lambda__3___closed__5 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__5(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__5); +l_Lake_Package_fetchOptRelease___lambda__3___closed__6 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__6(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__6); +l_Lake_Package_fetchOptRelease___lambda__3___closed__7 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__7(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__7); +l_Lake_Package_fetchOptRelease___lambda__3___closed__8 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__8(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__8); +l_Lake_Package_fetchOptRelease___lambda__3___closed__9 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__9(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__9); +l_Lake_Package_fetchOptRelease___lambda__3___closed__10 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__10(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__10); +l_Lake_Package_fetchOptRelease___lambda__3___closed__11 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__11(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__11); +l_Lake_Package_fetchOptRelease___lambda__3___closed__12 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__12(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__12); +l_Lake_Package_fetchOptRelease___lambda__3___closed__13 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__13(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__13); +l_Lake_Package_fetchOptRelease___lambda__3___closed__14 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__14(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__14); +l_Lake_Package_fetchOptRelease___lambda__3___closed__15 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__15(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__15); +l_Lake_Package_fetchOptRelease___lambda__3___closed__16 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__16(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__16); +l_Lake_Package_fetchOptRelease___lambda__3___closed__17 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__17(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__17); +l_Lake_Package_fetchOptRelease___lambda__3___closed__18 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__18(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__18); +l_Lake_Package_fetchOptRelease___lambda__3___closed__19 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__19(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__19); +l_Lake_Package_fetchOptRelease___lambda__3___closed__20 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__20(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__20); +l_Lake_Package_fetchOptRelease___lambda__3___closed__21 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__21(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__21); +l_Lake_Package_fetchOptRelease___lambda__3___closed__22 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__22(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__22); +l_Lake_Package_fetchOptRelease___lambda__3___closed__23 = _init_l_Lake_Package_fetchOptRelease___lambda__3___closed__23(); +lean_mark_persistent(l_Lake_Package_fetchOptRelease___lambda__3___closed__23); +l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__1 = _init_l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__1(); +lean_mark_persistent(l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__1); +l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__2 = _init_l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__2(); +lean_mark_persistent(l_Functor_discard___at_Lake_Package_optReleaseFacetConfig___spec__1___closed__2); +l_Lake_Package_optReleaseFacetConfig___closed__1 = _init_l_Lake_Package_optReleaseFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Package_optReleaseFacetConfig___closed__1); +l_Lake_Package_optReleaseFacetConfig___closed__2 = _init_l_Lake_Package_optReleaseFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Package_optReleaseFacetConfig___closed__2); +l_Lake_Package_optReleaseFacetConfig___closed__3 = _init_l_Lake_Package_optReleaseFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Package_optReleaseFacetConfig___closed__3); +l_Lake_Package_optReleaseFacetConfig___closed__4 = _init_l_Lake_Package_optReleaseFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Package_optReleaseFacetConfig___closed__4); +l_Lake_Package_optReleaseFacetConfig = _init_l_Lake_Package_optReleaseFacetConfig(); +lean_mark_persistent(l_Lake_Package_optReleaseFacetConfig); +l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__1 = _init_l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__1); +l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__2 = _init_l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___elambda__1___lambda__1___closed__2); +l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2___closed__1 = _init_l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___elambda__1___lambda__2___closed__1); +l_Lake_Package_releaseFacetConfig___elambda__1___closed__1 = _init_l_Lake_Package_releaseFacetConfig___elambda__1___closed__1(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___elambda__1___closed__1); +l_Lake_Package_releaseFacetConfig___elambda__1___closed__2 = _init_l_Lake_Package_releaseFacetConfig___elambda__1___closed__2(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___elambda__1___closed__2); +l_Lake_Package_releaseFacetConfig___closed__1 = _init_l_Lake_Package_releaseFacetConfig___closed__1(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___closed__1); +l_Lake_Package_releaseFacetConfig___closed__2 = _init_l_Lake_Package_releaseFacetConfig___closed__2(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___closed__2); +l_Lake_Package_releaseFacetConfig___closed__3 = _init_l_Lake_Package_releaseFacetConfig___closed__3(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___closed__3); +l_Lake_Package_releaseFacetConfig___closed__4 = _init_l_Lake_Package_releaseFacetConfig___closed__4(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig___closed__4); +l_Lake_Package_releaseFacetConfig = _init_l_Lake_Package_releaseFacetConfig(); +lean_mark_persistent(l_Lake_Package_releaseFacetConfig); +l_Lake_initPackageFacetConfigs___closed__1 = _init_l_Lake_initPackageFacetConfigs___closed__1(); +lean_mark_persistent(l_Lake_initPackageFacetConfigs___closed__1); +l_Lake_initPackageFacetConfigs___closed__2 = _init_l_Lake_initPackageFacetConfigs___closed__2(); +lean_mark_persistent(l_Lake_initPackageFacetConfigs___closed__2); +l_Lake_initPackageFacetConfigs___closed__3 = _init_l_Lake_initPackageFacetConfigs___closed__3(); +lean_mark_persistent(l_Lake_initPackageFacetConfigs___closed__3); +l_Lake_initPackageFacetConfigs___closed__4 = _init_l_Lake_initPackageFacetConfigs___closed__4(); +lean_mark_persistent(l_Lake_initPackageFacetConfigs___closed__4); +l_Lake_initPackageFacetConfigs = _init_l_Lake_initPackageFacetConfigs(); +lean_mark_persistent(l_Lake_initPackageFacetConfigs); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Run.c b/stage0/stdlib/Lake/Build/Run.c new file mode 100644 index 0000000000..e5cb8094e8 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Run.c @@ -0,0 +1,12151 @@ +// Lean compiler output +// Module: Lake.Build.Run +// Imports: Init Lake.Util.Lock Lake.Build.Index +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_Monitor_reportJob___lambda__2___closed__5; +lean_object* lean_format_pretty(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkBuildContext(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_MonitorM_run(lean_object*); +static lean_object* l_Lake_Monitor_reportJob___lambda__2___closed__3; +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +extern lean_object* l_Lake_instOrdLogLevel; +static lean_object* l_Lake_Monitor_spinnerFrames___closed__9; +static lean_object* l_Lake_Workspace_runFetchM___rarg___closed__5; +static lean_object* l_Lake_print_x21___closed__10; +lean_object* l_Lake_AnsiMode_isEnabled(lean_object*, uint8_t, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__2; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__3; +static lean_object* l_Lake_Monitor_spinnerFrames___closed__4; +lean_object* l_Lake_Ansi_chalk(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__1(lean_object*, uint8_t, uint8_t, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +uint64_t lean_uint64_mix_hash(uint64_t, uint64_t); +lean_object* lean_get_set_stdout(lean_object*, lean_object*); +static lean_object* l_Lake_mkBuildContext___closed__1; +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_String_quote(lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__8(lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__1; +lean_object* lean_array_push(lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__5; +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__4; +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__3; +LEAN_EXPORT lean_object* l_Lake_monitorJobs(lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MonitorState_jobNo___default; +uint8_t l_Lake_Log_maxLv(lean_object*); +uint8_t lean_usize_dec_eq(size_t, size_t); +LEAN_EXPORT lean_object* l_Lake_Monitor_flush(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_sleep(lean_object*, lean_object*, lean_object*); +lean_object* lean_array_fget(lean_object*, lean_object*); +static lean_object* l_Lake_mkBuildContext___closed__2; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_poll___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__3; +LEAN_EXPORT lean_object* l_Lake_print_x21(lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_instOrdJobAction; +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__2(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___closed__3; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__7(lean_object*); +uint64_t lean_string_hash(lean_object*); +static lean_object* l_Lake_Monitor_renderProgress___closed__5; +static lean_object* l_Lake_Monitor_spinnerFrames___closed__6; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Workspace_runBuild___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_JobAction_verb(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_poll___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Fin_add(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Monitor_spinnerFrames___closed__5; +lean_object* l_Lake_OutStream_get(lean_object*, lean_object*); +lean_object* lean_string_push(lean_object*, uint32_t); +uint8_t lean_string_validate_utf8(lean_object*); +static lean_object* l_Lake_Monitor_reportJob___lambda__2___closed__6; +extern lean_object* l_instInhabitedPUnit; +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__3___boxed__const__1; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_print_x21___closed__7; +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__1; +size_t lean_usize_of_nat(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_renderProgress(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_String_isEmpty(lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_object* lean_io_mono_ms_now(lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__1; +uint8_t l_instDecidableNot___rarg(uint8_t); +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__8___boxed__const__1; +static lean_object* l_Lake_Workspace_runFetchM___rarg___closed__2; +static lean_object* l_Lake_Monitor_renderProgress___closed__2; +lean_object* lean_nat_to_int(lean_object*); +uint32_t lean_uint32_of_nat(lean_object*); +extern lean_object* l_ByteArray_empty; +static lean_object* l_Lake_print_x21___closed__8; +static lean_object* l_Lake_Monitor_spinnerFrames___closed__1; +static lean_object* l_Lake_print_x21___closed__6; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__2(lean_object*, uint8_t, uint8_t, lean_object*, size_t, size_t, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__2; +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames; +lean_object* l_Lake_recFetch___at_Lake_FetchM_run___spec__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__2; +LEAN_EXPORT lean_object* l_Lake_Monitor_sleep___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Monitor_renderProgress___closed__3; +static uint8_t l_Lake_Monitor_reportJob___lambda__2___closed__8; +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_logToStream(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*); +static lean_object* l_Lake_print_x21___closed__1; +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__4___boxed__const__1; +lean_object* l_IO_sleep(uint32_t, lean_object*); +uint8_t l_Lake_Verbosity_minLogLv(uint8_t); +lean_object* lean_st_ref_get(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static uint8_t l_Lake_Monitor_reportJob___lambda__2___closed__9; +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_st_mk_ref(lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__9; +LEAN_EXPORT lean_object* l_Lake_Monitor_loop(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MonitorState_spinnerIdx___default; +lean_object* l_panic___at_String_fromUTF8_x21___spec__1(lean_object*); +static lean_object* l_Lake_Monitor_reportJob___lambda__2___closed__1; +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__4(lean_object*); +LEAN_EXPORT lean_object* l_panic___at_Lake_print_x21___spec__1(lean_object*, lean_object*); +lean_object* l_Lake_LogLevel_ansiColor(uint8_t); +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__7___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_runBuild(lean_object*); +lean_object* l_IO_FS_Stream_ofBuffer(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_instMonadBaseIO; +lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Monitor_renderProgress___closed__4; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__1; +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__8; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_get_set_stderr(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lake_BuildConfig_showProgress(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_renderProgress___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__2(lean_object*, uint8_t, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_print_x21___closed__3; +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__5___boxed__const__1; +lean_object* lean_task_get_own(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__6; +extern lean_object* l_Std_Format_defWidth; +lean_object* lean_string_from_utf8(lean_object*); +static lean_object* l_Lake_print_x21___closed__5; +static lean_object* l_Lake_mkBuildContext___closed__3; +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Ansi_resetLine___closed__1; +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__6___boxed__const__1; +static lean_object* l_Lake_Monitor_spinnerFrames___closed__7; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__4___closed__1; +static lean_object* l_Lake_Monitor_sleep___closed__1; +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__5; +uint8_t l_Lake_instDecidableEqVerbosity(uint8_t, uint8_t); +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__2___boxed__const__1; +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__2(lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*); +static lean_object* l_Lake_Monitor_spinnerFrames___closed__8; +static lean_object* l_Lake_Monitor_renderProgress___closed__1; +static lean_object* l_Lake_Monitor_poll___closed__1; +LEAN_EXPORT lean_object* l_Lake_Ansi_resetLine; +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__5(lean_object*); +static lean_object* l_Lake_Monitor_spinnerFrames___closed__2; +uint8_t lean_nat_dec_eq(lean_object*, lean_object*); +static lean_object* l_Lake_print_x21___closed__11; +static lean_object* l_Lake_Workspace_runFetchM___rarg___closed__6; +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +static lean_object* l_Lake_print_x21___closed__12; +LEAN_EXPORT lean_object* l_Lake_Monitor_sleep___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +uint32_t l_Lake_LogLevel_icon(uint8_t); +lean_object* l_Lake_Env_leanGithash(lean_object*); +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_poll(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_get_task_state(lean_object*, lean_object*); +uint8_t l_instDecidableRelLe___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__11; +static lean_object* l_Lake_print_x21___closed__4; +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_panic_fn(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MonitorM_run___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +lean_object* lean_nat_sub(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5(lean_object*, lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*); +lean_object* lean_get_set_stdin(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__7___boxed__const__1; +static lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__4; +LEAN_EXPORT lean_object* l_Lake_Monitor_poll___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_panic___at_Lake_print_x21___spec__1___closed__1; +static lean_object* l_Lake_Monitor_reportJob___lambda__2___closed__2; +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Workspace_runFetchM___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +size_t lean_usize_add(size_t, size_t); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__3; +static lean_object* l_Lake_Workspace_runFetchM___rarg___closed__4; +lean_object* lean_array_uget(lean_object*, size_t); +static lean_object* l_Lake_Monitor_reportJob___lambda__2___closed__7; +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_error_to_string(lean_object*); +lean_object* l_instInhabitedOfMonad___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_print_x21___closed__9; +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_runBuild___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_print_x21___closed__2; +LEAN_EXPORT lean_object* l_Lake_flush(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3(lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__7; +lean_object* lean_string_append(lean_object*, lean_object*); +lean_object* lean_io_wait(lean_object*, lean_object*); +static lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___closed__1; +lean_object* lean_array_get_size(lean_object*); +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10; +LEAN_EXPORT lean_object* l_Lake_Monitor_print(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +lean_object* lean_nat_add(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Workspace_runFetchM___spec__6(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Workspace_runBuild(lean_object*); +static lean_object* l_Lake_Monitor_renderProgress___closed__6; +static lean_object* l_Lake_Monitor_spinnerFrames___closed__3; +lean_object* l___private_Init_Data_Repr_0__Nat_reprFast(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Monitor_spinnerFrames___closed__9___boxed__const__1; +lean_object* l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Monitor_reportJob___lambda__2___closed__4; +static lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__4; +LEAN_EXPORT lean_object* l_Lake_Monitor_main(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_monitorJobs___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*); +uint8_t l_Array_isEmpty___rarg(lean_object*); +static lean_object* _init_l_Lake_mkBuildContext___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_mkBuildContext___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_mkBuildContext___closed__3() { +_start: +{ +uint32_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 0; +x_2 = l_Lake_mkBuildContext___closed__2; +x_3 = lean_alloc_ctor(0, 1, 4); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint32(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_mkBuildContext(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = l_Lake_mkBuildContext___closed__1; +x_5 = lean_st_mk_ref(x_4, x_3); +if (lean_obj_tag(x_5) == 0) +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; uint64_t x_10; uint64_t x_11; uint64_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_7 = lean_ctor_get(x_5, 0); +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = l_Lake_Env_leanGithash(x_8); +lean_dec(x_8); +x_10 = lean_string_hash(x_9); +lean_dec(x_9); +x_11 = 1723; +x_12 = lean_uint64_mix_hash(x_11, x_10); +x_13 = l_Lake_mkBuildContext___closed__3; +x_14 = lean_box_uint64(x_12); +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_13); +x_16 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_16, 0, x_2); +lean_ctor_set(x_16, 1, x_1); +lean_ctor_set(x_16, 2, x_15); +lean_ctor_set(x_16, 3, x_7); +lean_ctor_set(x_5, 0, x_16); +return x_5; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint64_t x_21; uint64_t x_22; uint64_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_17 = lean_ctor_get(x_5, 0); +x_18 = lean_ctor_get(x_5, 1); +lean_inc(x_18); +lean_inc(x_17); +lean_dec(x_5); +x_19 = lean_ctor_get(x_1, 1); +lean_inc(x_19); +x_20 = l_Lake_Env_leanGithash(x_19); +lean_dec(x_19); +x_21 = lean_string_hash(x_20); +lean_dec(x_20); +x_22 = 1723; +x_23 = lean_uint64_mix_hash(x_22, x_21); +x_24 = l_Lake_mkBuildContext___closed__3; +x_25 = lean_box_uint64(x_23); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_24); +x_27 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_27, 0, x_2); +lean_ctor_set(x_27, 1, x_1); +lean_ctor_set(x_27, 2, x_26); +lean_ctor_set(x_27, 3, x_17); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_18); +return x_28; +} +} +else +{ +uint8_t x_29; +lean_dec(x_2); +lean_dec(x_1); +x_29 = !lean_is_exclusive(x_5); +if (x_29 == 0) +{ +return x_5; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_5, 0); +x_31 = lean_ctor_get(x_5, 1); +lean_inc(x_31); +lean_inc(x_30); +lean_dec(x_5); +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_31); +return x_32; +} +} +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(8u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__2___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10494; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__1; +x_2 = l_Lake_Monitor_spinnerFrames___closed__2___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__3___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10487; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__2; +x_2 = l_Lake_Monitor_spinnerFrames___closed__3___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__4___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10479; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__3; +x_2 = l_Lake_Monitor_spinnerFrames___closed__4___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__5___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10463; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__4; +x_2 = l_Lake_Monitor_spinnerFrames___closed__5___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__6___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10367; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__5; +x_2 = l_Lake_Monitor_spinnerFrames___closed__6___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__7___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10431; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__6; +x_2 = l_Lake_Monitor_spinnerFrames___closed__7___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__8___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10491; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__7; +x_2 = l_Lake_Monitor_spinnerFrames___closed__8___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__9___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 10493; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_spinnerFrames___closed__8; +x_2 = l_Lake_Monitor_spinnerFrames___closed__9___boxed__const__1; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_spinnerFrames() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Monitor_spinnerFrames___closed__9; +return x_1; +} +} +static lean_object* _init_l_Lake_MonitorState_jobNo___default() { +_start: +{ +lean_object* x_1; +x_1 = lean_unsigned_to_nat(1u); +return x_1; +} +} +static lean_object* _init_l_Lake_MonitorState_spinnerIdx___default() { +_start: +{ +lean_object* x_1; +x_1 = lean_unsigned_to_nat(0u); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_MonitorM_run___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_apply_3(x_3, x_1, x_2, x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_MonitorM_run(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_MonitorM_run___rarg), 4, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_Ansi_resetLine___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("\x1b[2K\r", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_Ansi_resetLine() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Ansi_resetLine___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_flush(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = lean_apply_1(x_3, x_2); +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; +x_5 = !lean_is_exclusive(x_4); +if (x_5 == 0) +{ +return x_4; +} +else +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_ctor_get(x_4, 0); +x_7 = lean_ctor_get(x_4, 1); +lean_inc(x_7); +lean_inc(x_6); +lean_dec(x_4); +x_8 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_8, 0, x_6); +lean_ctor_set(x_8, 1, x_7); +return x_8; +} +} +else +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_4); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_4, 0); +lean_dec(x_10); +x_11 = lean_box(0); +lean_ctor_set_tag(x_4, 0); +lean_ctor_set(x_4, 0, x_11); +return x_4; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_4, 1); +lean_inc(x_12); +lean_dec(x_4); +x_13 = lean_box(0); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +return x_14; +} +} +} +} +static lean_object* _init_l_panic___at_Lake_print_x21___spec__1___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_instMonadBaseIO; +x_2 = l_instInhabitedPUnit; +x_3 = l_instInhabitedOfMonad___rarg(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_panic___at_Lake_print_x21___spec__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; +x_3 = l_panic___at_Lake_print_x21___spec__1___closed__1; +x_4 = lean_panic_fn(x_3, x_1); +x_5 = lean_apply_1(x_4, x_2); +return x_5; +} +} +static lean_object* _init_l_Lake_print_x21___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_print_x21___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("print!", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_print_x21___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_print_x21___closed__1; +x_2 = l_Lake_print_x21___closed__2; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_print_x21___closed__4() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l_Lake_print_x21___closed__3; +x_2 = 1; +x_3 = l_Lean_Name_toString(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_print_x21___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("[", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_print_x21___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_print_x21___closed__5; +x_2 = l_Lake_print_x21___closed__4; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_print_x21___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" failed: ", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_print_x21___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_print_x21___closed__6; +x_2 = l_Lake_print_x21___closed__7; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_print_x21___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("] ", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_print_x21___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_print_x21___closed__11() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.Build.Run", 14); +return x_1; +} +} +static lean_object* _init_l_Lake_print_x21___closed__12() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.print!", 11); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_print_x21(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_1, 4); +lean_inc(x_4); +lean_dec(x_1); +lean_inc(x_2); +x_5 = lean_apply_2(x_4, x_2, x_3); +if (lean_obj_tag(x_5) == 0) +{ +uint8_t x_6; +lean_dec(x_2); +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +return x_5; +} +else +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_7 = lean_ctor_get(x_5, 0); +x_8 = lean_ctor_get(x_5, 1); +lean_inc(x_8); +lean_inc(x_7); +lean_dec(x_5); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_7); +lean_ctor_set(x_9, 1, x_8); +return x_9; +} +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_10 = lean_ctor_get(x_5, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_5, 1); +lean_inc(x_11); +lean_dec(x_5); +x_12 = lean_io_error_to_string(x_10); +x_13 = l_Lake_print_x21___closed__8; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lake_print_x21___closed__9; +x_16 = lean_string_append(x_14, x_15); +x_17 = l_String_quote(x_2); +lean_dec(x_2); +x_18 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_18, 0, x_17); +x_19 = l_Std_Format_defWidth; +x_20 = lean_unsigned_to_nat(0u); +x_21 = lean_format_pretty(x_18, x_19, x_20, x_20); +x_22 = lean_string_append(x_16, x_21); +lean_dec(x_21); +x_23 = l_Lake_print_x21___closed__10; +x_24 = lean_string_append(x_22, x_23); +x_25 = l_Lake_print_x21___closed__11; +x_26 = l_Lake_print_x21___closed__12; +x_27 = lean_unsigned_to_nat(74u); +x_28 = lean_unsigned_to_nat(4u); +x_29 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_25, x_26, x_27, x_28, x_24); +lean_dec(x_24); +x_30 = l_panic___at_Lake_print_x21___spec__1(x_29, x_11); +return x_30; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_print(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +lean_dec(x_2); +x_6 = lean_ctor_get(x_5, 4); +lean_inc(x_6); +lean_dec(x_5); +lean_inc(x_1); +x_7 = lean_apply_2(x_6, x_1, x_4); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +lean_dec(x_1); +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_3); +lean_ctor_set(x_7, 0, x_10); +return x_7; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get(x_7, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_7); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_3); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_15 = lean_ctor_get(x_7, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_7, 1); +lean_inc(x_16); +lean_dec(x_7); +x_17 = lean_io_error_to_string(x_15); +x_18 = l_Lake_print_x21___closed__8; +x_19 = lean_string_append(x_18, x_17); +lean_dec(x_17); +x_20 = l_Lake_print_x21___closed__9; +x_21 = lean_string_append(x_19, x_20); +x_22 = l_String_quote(x_1); +lean_dec(x_1); +x_23 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_23, 0, x_22); +x_24 = l_Std_Format_defWidth; +x_25 = lean_unsigned_to_nat(0u); +x_26 = lean_format_pretty(x_23, x_24, x_25, x_25); +x_27 = lean_string_append(x_21, x_26); +lean_dec(x_26); +x_28 = l_Lake_print_x21___closed__10; +x_29 = lean_string_append(x_27, x_28); +x_30 = l_Lake_print_x21___closed__11; +x_31 = l_Lake_print_x21___closed__12; +x_32 = lean_unsigned_to_nat(74u); +x_33 = lean_unsigned_to_nat(4u); +x_34 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_30, x_31, x_32, x_33, x_29); +lean_dec(x_29); +x_35 = l_panic___at_Lake_print_x21___spec__1(x_34, x_16); +if (lean_obj_tag(x_35) == 0) +{ +uint8_t x_36; +x_36 = !lean_is_exclusive(x_35); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; +x_37 = lean_ctor_get(x_35, 0); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_3); +lean_ctor_set(x_35, 0, x_38); +return x_35; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_39 = lean_ctor_get(x_35, 0); +x_40 = lean_ctor_get(x_35, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_35); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_3); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_40); +return x_42; +} +} +else +{ +uint8_t x_43; +lean_dec(x_3); +x_43 = !lean_is_exclusive(x_35); +if (x_43 == 0) +{ +return x_35; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_35, 0); +x_45 = lean_ctor_get(x_35, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_35); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +return x_46; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_flush(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +lean_dec(x_1); +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +lean_dec(x_4); +x_6 = lean_apply_1(x_5, x_3); +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_ctor_get(x_6, 0); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_2); +lean_ctor_set(x_6, 0, x_9); +return x_6; +} +else +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_10 = lean_ctor_get(x_6, 0); +x_11 = lean_ctor_get(x_6, 1); +lean_inc(x_11); +lean_inc(x_10); +lean_dec(x_6); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_10); +lean_ctor_set(x_12, 1, x_2); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +return x_13; +} +} +else +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_6); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_6, 0); +lean_dec(x_15); +x_16 = lean_box(0); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_2); +lean_ctor_set_tag(x_6, 0); +lean_ctor_set(x_6, 0, x_17); +return x_6; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_6, 1); +lean_inc(x_18); +lean_dec(x_6); +x_19 = lean_box(0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_2); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_18); +return x_21; +} +} +} +} +static lean_object* _init_l_Lake_Monitor_renderProgress___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Monitor_spinnerFrames; +x_2 = lean_array_get_size(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Monitor_renderProgress___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" [", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_Monitor_renderProgress___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("/", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Monitor_renderProgress___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Running ", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Monitor_renderProgress___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" (+ ", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Monitor_renderProgress___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" more)", 6); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_renderProgress(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = lean_ctor_get_uint8(x_4, sizeof(void*)*3 + 4); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_dec(x_4); +x_8 = lean_box(0); +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_5); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_6); +return x_10; +} +else +{ +uint8_t x_11; +x_11 = lean_ctor_get_uint8(x_4, sizeof(void*)*3 + 3); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_4); +x_12 = lean_box(0); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_5); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_6); +return x_14; +} +else +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_5); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint32_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_16 = lean_ctor_get(x_5, 0); +x_17 = lean_ctor_get(x_5, 2); +x_18 = lean_ctor_get(x_5, 4); +x_19 = lean_ctor_get(x_4, 0); +lean_inc(x_19); +x_20 = lean_ctor_get(x_4, 1); +lean_inc(x_20); +lean_dec(x_4); +x_21 = l_Lake_Monitor_spinnerFrames; +x_22 = lean_array_fget(x_21, x_18); +x_23 = lean_unbox_uint32(x_22); +lean_dec(x_22); +x_24 = l_Lake_Monitor_renderProgress___closed__1; +x_25 = lean_unsigned_to_nat(1u); +x_26 = l_Fin_add(x_24, x_18, x_25); +lean_dec(x_18); +x_27 = l_Lake_Ansi_resetLine; +lean_inc(x_16); +lean_ctor_set(x_5, 4, x_26); +lean_ctor_set(x_5, 2, x_27); +x_28 = lean_array_get_size(x_1); +x_29 = lean_unsigned_to_nat(0u); +x_30 = lean_nat_dec_lt(x_29, x_28); +x_31 = l_Lake_print_x21___closed__10; +x_32 = lean_string_append(x_31, x_17); +lean_dec(x_17); +x_33 = lean_string_append(x_32, x_31); +x_34 = lean_string_push(x_31, x_23); +x_35 = lean_string_append(x_33, x_34); +lean_dec(x_34); +x_36 = l_Lake_Monitor_renderProgress___closed__2; +x_37 = lean_string_append(x_35, x_36); +x_38 = l___private_Init_Data_Repr_0__Nat_reprFast(x_16); +x_39 = lean_string_append(x_37, x_38); +lean_dec(x_38); +x_40 = l_Lake_Monitor_renderProgress___closed__3; +x_41 = lean_string_append(x_39, x_40); +x_42 = l___private_Init_Data_Repr_0__Nat_reprFast(x_19); +x_43 = lean_string_append(x_41, x_42); +lean_dec(x_42); +x_44 = l_Lake_print_x21___closed__9; +x_45 = lean_string_append(x_43, x_44); +x_46 = lean_ctor_get(x_20, 4); +lean_inc(x_46); +if (x_30 == 0) +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; +lean_dec(x_28); +x_153 = lean_array_fget(x_2, x_29); +x_154 = lean_ctor_get(x_153, 1); +lean_inc(x_154); +lean_dec(x_153); +x_155 = l_Lake_Monitor_renderProgress___closed__4; +x_156 = lean_string_append(x_155, x_154); +lean_dec(x_154); +x_157 = lean_string_append(x_156, x_31); +x_47 = x_157; +goto block_152; +} +else +{ +lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; +x_158 = lean_array_fget(x_1, x_29); +x_159 = lean_ctor_get(x_158, 1); +lean_inc(x_159); +lean_dec(x_158); +x_160 = l_Lake_Monitor_renderProgress___closed__4; +x_161 = lean_string_append(x_160, x_159); +lean_dec(x_159); +x_162 = l_Lake_Monitor_renderProgress___closed__5; +x_163 = lean_string_append(x_161, x_162); +x_164 = lean_nat_sub(x_28, x_25); +lean_dec(x_28); +x_165 = l___private_Init_Data_Repr_0__Nat_reprFast(x_164); +x_166 = lean_string_append(x_163, x_165); +lean_dec(x_165); +x_167 = l_Lake_Monitor_renderProgress___closed__6; +x_168 = lean_string_append(x_166, x_167); +x_47 = x_168; +goto block_152; +} +block_152: +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_string_append(x_45, x_47); +lean_dec(x_47); +x_49 = lean_string_append(x_48, x_31); +lean_inc(x_49); +x_50 = lean_apply_2(x_46, x_49, x_6); +if (lean_obj_tag(x_50) == 0) +{ +uint8_t x_51; +lean_dec(x_49); +x_51 = !lean_is_exclusive(x_50); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_50, 1); +x_53 = lean_ctor_get(x_50, 0); +lean_dec(x_53); +x_54 = lean_ctor_get(x_20, 0); +lean_inc(x_54); +lean_dec(x_20); +x_55 = lean_apply_1(x_54, x_52); +if (lean_obj_tag(x_55) == 0) +{ +uint8_t x_56; +x_56 = !lean_is_exclusive(x_55); +if (x_56 == 0) +{ +lean_object* x_57; +x_57 = lean_ctor_get(x_55, 0); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_57); +lean_ctor_set(x_55, 0, x_50); +return x_55; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_55, 0); +x_59 = lean_ctor_get(x_55, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_55); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_58); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_50); +lean_ctor_set(x_60, 1, x_59); +return x_60; +} +} +else +{ +uint8_t x_61; +x_61 = !lean_is_exclusive(x_55); +if (x_61 == 0) +{ +lean_object* x_62; lean_object* x_63; +x_62 = lean_ctor_get(x_55, 0); +lean_dec(x_62); +x_63 = lean_box(0); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_63); +lean_ctor_set_tag(x_55, 0); +lean_ctor_set(x_55, 0, x_50); +return x_55; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_55, 1); +lean_inc(x_64); +lean_dec(x_55); +x_65 = lean_box(0); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_65); +x_66 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_66, 0, x_50); +lean_ctor_set(x_66, 1, x_64); +return x_66; +} +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_dec(x_50); +x_68 = lean_ctor_get(x_20, 0); +lean_inc(x_68); +lean_dec(x_20); +x_69 = lean_apply_1(x_68, x_67); +if (lean_obj_tag(x_69) == 0) +{ +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); +if (lean_is_exclusive(x_69)) { + lean_ctor_release(x_69, 0); + lean_ctor_release(x_69, 1); + x_72 = x_69; +} else { + lean_dec_ref(x_69); + x_72 = lean_box(0); +} +x_73 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_73, 0, x_70); +lean_ctor_set(x_73, 1, x_5); +if (lean_is_scalar(x_72)) { + x_74 = lean_alloc_ctor(0, 2, 0); +} else { + x_74 = x_72; +} +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_71); +return x_74; +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_75 = lean_ctor_get(x_69, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_69)) { + lean_ctor_release(x_69, 0); + lean_ctor_release(x_69, 1); + x_76 = x_69; +} else { + lean_dec_ref(x_69); + x_76 = lean_box(0); +} +x_77 = lean_box(0); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_5); +if (lean_is_scalar(x_76)) { + x_79 = lean_alloc_ctor(0, 2, 0); +} else { + x_79 = x_76; + lean_ctor_set_tag(x_79, 0); +} +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_75); +return x_79; +} +} +} +else +{ +uint8_t x_80; +x_80 = !lean_is_exclusive(x_50); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_81 = lean_ctor_get(x_50, 0); +x_82 = lean_ctor_get(x_50, 1); +x_83 = lean_io_error_to_string(x_81); +x_84 = l_Lake_print_x21___closed__8; +x_85 = lean_string_append(x_84, x_83); +lean_dec(x_83); +x_86 = lean_string_append(x_85, x_44); +x_87 = l_String_quote(x_49); +lean_dec(x_49); +x_88 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_88, 0, x_87); +x_89 = l_Std_Format_defWidth; +x_90 = lean_format_pretty(x_88, x_89, x_29, x_29); +x_91 = lean_string_append(x_86, x_90); +lean_dec(x_90); +x_92 = lean_string_append(x_91, x_31); +x_93 = l_Lake_print_x21___closed__11; +x_94 = l_Lake_print_x21___closed__12; +x_95 = lean_unsigned_to_nat(74u); +x_96 = lean_unsigned_to_nat(4u); +x_97 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_93, x_94, x_95, x_96, x_92); +lean_dec(x_92); +x_98 = l_panic___at_Lake_print_x21___spec__1(x_97, x_82); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_100 = lean_ctor_get(x_20, 0); +lean_inc(x_100); +lean_dec(x_20); +x_101 = lean_apply_1(x_100, x_99); +if (lean_obj_tag(x_101) == 0) +{ +uint8_t x_102; +x_102 = !lean_is_exclusive(x_101); +if (x_102 == 0) +{ +lean_object* x_103; +x_103 = lean_ctor_get(x_101, 0); +lean_ctor_set_tag(x_50, 0); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_103); +lean_ctor_set(x_101, 0, x_50); +return x_101; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_101, 0); +x_105 = lean_ctor_get(x_101, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_101); +lean_ctor_set_tag(x_50, 0); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_104); +x_106 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_106, 0, x_50); +lean_ctor_set(x_106, 1, x_105); +return x_106; +} +} +else +{ +uint8_t x_107; +x_107 = !lean_is_exclusive(x_101); +if (x_107 == 0) +{ +lean_object* x_108; lean_object* x_109; +x_108 = lean_ctor_get(x_101, 0); +lean_dec(x_108); +x_109 = lean_box(0); +lean_ctor_set_tag(x_50, 0); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_109); +lean_ctor_set_tag(x_101, 0); +lean_ctor_set(x_101, 0, x_50); +return x_101; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_101, 1); +lean_inc(x_110); +lean_dec(x_101); +x_111 = lean_box(0); +lean_ctor_set_tag(x_50, 0); +lean_ctor_set(x_50, 1, x_5); +lean_ctor_set(x_50, 0, x_111); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_50); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_free_object(x_50); +lean_dec(x_5); +lean_dec(x_20); +x_113 = !lean_is_exclusive(x_98); +if (x_113 == 0) +{ +return x_98; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_98, 0); +x_115 = lean_ctor_get(x_98, 1); +lean_inc(x_115); +lean_inc(x_114); +lean_dec(x_98); +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; +} +} +} +else +{ +lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_117 = lean_ctor_get(x_50, 0); +x_118 = lean_ctor_get(x_50, 1); +lean_inc(x_118); +lean_inc(x_117); +lean_dec(x_50); +x_119 = lean_io_error_to_string(x_117); +x_120 = l_Lake_print_x21___closed__8; +x_121 = lean_string_append(x_120, x_119); +lean_dec(x_119); +x_122 = lean_string_append(x_121, x_44); +x_123 = l_String_quote(x_49); +lean_dec(x_49); +x_124 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_124, 0, x_123); +x_125 = l_Std_Format_defWidth; +x_126 = lean_format_pretty(x_124, x_125, x_29, x_29); +x_127 = lean_string_append(x_122, x_126); +lean_dec(x_126); +x_128 = lean_string_append(x_127, x_31); +x_129 = l_Lake_print_x21___closed__11; +x_130 = l_Lake_print_x21___closed__12; +x_131 = lean_unsigned_to_nat(74u); +x_132 = lean_unsigned_to_nat(4u); +x_133 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_129, x_130, x_131, x_132, x_128); +lean_dec(x_128); +x_134 = l_panic___at_Lake_print_x21___spec__1(x_133, x_118); +if (lean_obj_tag(x_134) == 0) +{ +lean_object* x_135; lean_object* x_136; lean_object* x_137; +x_135 = lean_ctor_get(x_134, 1); +lean_inc(x_135); +lean_dec(x_134); +x_136 = lean_ctor_get(x_20, 0); +lean_inc(x_136); +lean_dec(x_20); +x_137 = lean_apply_1(x_136, x_135); +if (lean_obj_tag(x_137) == 0) +{ +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_137, 0); +lean_inc(x_138); +x_139 = lean_ctor_get(x_137, 1); +lean_inc(x_139); +if (lean_is_exclusive(x_137)) { + lean_ctor_release(x_137, 0); + lean_ctor_release(x_137, 1); + x_140 = x_137; +} else { + lean_dec_ref(x_137); + x_140 = lean_box(0); +} +x_141 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_141, 0, x_138); +lean_ctor_set(x_141, 1, x_5); +if (lean_is_scalar(x_140)) { + x_142 = lean_alloc_ctor(0, 2, 0); +} else { + x_142 = x_140; +} +lean_ctor_set(x_142, 0, x_141); +lean_ctor_set(x_142, 1, x_139); +return x_142; +} +else +{ +lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_143 = lean_ctor_get(x_137, 1); +lean_inc(x_143); +if (lean_is_exclusive(x_137)) { + lean_ctor_release(x_137, 0); + lean_ctor_release(x_137, 1); + x_144 = x_137; +} else { + lean_dec_ref(x_137); + x_144 = lean_box(0); +} +x_145 = lean_box(0); +x_146 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_146, 0, x_145); +lean_ctor_set(x_146, 1, x_5); +if (lean_is_scalar(x_144)) { + x_147 = lean_alloc_ctor(0, 2, 0); +} else { + x_147 = x_144; + lean_ctor_set_tag(x_147, 0); +} +lean_ctor_set(x_147, 0, x_146); +lean_ctor_set(x_147, 1, x_143); +return x_147; +} +} +else +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +lean_dec(x_5); +lean_dec(x_20); +x_148 = lean_ctor_get(x_134, 0); +lean_inc(x_148); +x_149 = lean_ctor_get(x_134, 1); +lean_inc(x_149); +if (lean_is_exclusive(x_134)) { + lean_ctor_release(x_134, 0); + lean_ctor_release(x_134, 1); + x_150 = x_134; +} else { + lean_dec_ref(x_134); + x_150 = lean_box(0); +} +if (lean_is_scalar(x_150)) { + x_151 = lean_alloc_ctor(1, 2, 0); +} else { + x_151 = x_150; +} +lean_ctor_set(x_151, 0, x_148); +lean_ctor_set(x_151, 1, x_149); +return x_151; +} +} +} +} +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint32_t x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_169 = lean_ctor_get(x_5, 0); +x_170 = lean_ctor_get(x_5, 1); +x_171 = lean_ctor_get(x_5, 2); +x_172 = lean_ctor_get(x_5, 3); +x_173 = lean_ctor_get(x_5, 4); +lean_inc(x_173); +lean_inc(x_172); +lean_inc(x_171); +lean_inc(x_170); +lean_inc(x_169); +lean_dec(x_5); +x_174 = lean_ctor_get(x_4, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_4, 1); +lean_inc(x_175); +lean_dec(x_4); +x_176 = l_Lake_Monitor_spinnerFrames; +x_177 = lean_array_fget(x_176, x_173); +x_178 = lean_unbox_uint32(x_177); +lean_dec(x_177); +x_179 = l_Lake_Monitor_renderProgress___closed__1; +x_180 = lean_unsigned_to_nat(1u); +x_181 = l_Fin_add(x_179, x_173, x_180); +lean_dec(x_173); +x_182 = l_Lake_Ansi_resetLine; +lean_inc(x_169); +x_183 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_183, 0, x_169); +lean_ctor_set(x_183, 1, x_170); +lean_ctor_set(x_183, 2, x_182); +lean_ctor_set(x_183, 3, x_172); +lean_ctor_set(x_183, 4, x_181); +x_184 = lean_array_get_size(x_1); +x_185 = lean_unsigned_to_nat(0u); +x_186 = lean_nat_dec_lt(x_185, x_184); +x_187 = l_Lake_print_x21___closed__10; +x_188 = lean_string_append(x_187, x_171); +lean_dec(x_171); +x_189 = lean_string_append(x_188, x_187); +x_190 = lean_string_push(x_187, x_178); +x_191 = lean_string_append(x_189, x_190); +lean_dec(x_190); +x_192 = l_Lake_Monitor_renderProgress___closed__2; +x_193 = lean_string_append(x_191, x_192); +x_194 = l___private_Init_Data_Repr_0__Nat_reprFast(x_169); +x_195 = lean_string_append(x_193, x_194); +lean_dec(x_194); +x_196 = l_Lake_Monitor_renderProgress___closed__3; +x_197 = lean_string_append(x_195, x_196); +x_198 = l___private_Init_Data_Repr_0__Nat_reprFast(x_174); +x_199 = lean_string_append(x_197, x_198); +lean_dec(x_198); +x_200 = l_Lake_print_x21___closed__9; +x_201 = lean_string_append(x_199, x_200); +x_202 = lean_ctor_get(x_175, 4); +lean_inc(x_202); +if (x_186 == 0) +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; +lean_dec(x_184); +x_258 = lean_array_fget(x_2, x_185); +x_259 = lean_ctor_get(x_258, 1); +lean_inc(x_259); +lean_dec(x_258); +x_260 = l_Lake_Monitor_renderProgress___closed__4; +x_261 = lean_string_append(x_260, x_259); +lean_dec(x_259); +x_262 = lean_string_append(x_261, x_187); +x_203 = x_262; +goto block_257; +} +else +{ +lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; +x_263 = lean_array_fget(x_1, x_185); +x_264 = lean_ctor_get(x_263, 1); +lean_inc(x_264); +lean_dec(x_263); +x_265 = l_Lake_Monitor_renderProgress___closed__4; +x_266 = lean_string_append(x_265, x_264); +lean_dec(x_264); +x_267 = l_Lake_Monitor_renderProgress___closed__5; +x_268 = lean_string_append(x_266, x_267); +x_269 = lean_nat_sub(x_184, x_180); +lean_dec(x_184); +x_270 = l___private_Init_Data_Repr_0__Nat_reprFast(x_269); +x_271 = lean_string_append(x_268, x_270); +lean_dec(x_270); +x_272 = l_Lake_Monitor_renderProgress___closed__6; +x_273 = lean_string_append(x_271, x_272); +x_203 = x_273; +goto block_257; +} +block_257: +{ +lean_object* x_204; lean_object* x_205; lean_object* x_206; +x_204 = lean_string_append(x_201, x_203); +lean_dec(x_203); +x_205 = lean_string_append(x_204, x_187); +lean_inc(x_205); +x_206 = lean_apply_2(x_202, x_205, x_6); +if (lean_obj_tag(x_206) == 0) +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +lean_dec(x_205); +x_207 = lean_ctor_get(x_206, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_206)) { + lean_ctor_release(x_206, 0); + lean_ctor_release(x_206, 1); + x_208 = x_206; +} else { + lean_dec_ref(x_206); + x_208 = lean_box(0); +} +x_209 = lean_ctor_get(x_175, 0); +lean_inc(x_209); +lean_dec(x_175); +x_210 = lean_apply_1(x_209, x_207); +if (lean_obj_tag(x_210) == 0) +{ +lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_211 = lean_ctor_get(x_210, 0); +lean_inc(x_211); +x_212 = lean_ctor_get(x_210, 1); +lean_inc(x_212); +if (lean_is_exclusive(x_210)) { + lean_ctor_release(x_210, 0); + lean_ctor_release(x_210, 1); + x_213 = x_210; +} else { + lean_dec_ref(x_210); + x_213 = lean_box(0); +} +if (lean_is_scalar(x_208)) { + x_214 = lean_alloc_ctor(0, 2, 0); +} else { + x_214 = x_208; +} +lean_ctor_set(x_214, 0, x_211); +lean_ctor_set(x_214, 1, x_183); +if (lean_is_scalar(x_213)) { + x_215 = lean_alloc_ctor(0, 2, 0); +} else { + x_215 = x_213; +} +lean_ctor_set(x_215, 0, x_214); +lean_ctor_set(x_215, 1, x_212); +return x_215; +} +else +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; +x_216 = lean_ctor_get(x_210, 1); +lean_inc(x_216); +if (lean_is_exclusive(x_210)) { + lean_ctor_release(x_210, 0); + lean_ctor_release(x_210, 1); + x_217 = x_210; +} else { + lean_dec_ref(x_210); + x_217 = lean_box(0); +} +x_218 = lean_box(0); +if (lean_is_scalar(x_208)) { + x_219 = lean_alloc_ctor(0, 2, 0); +} else { + x_219 = x_208; +} +lean_ctor_set(x_219, 0, x_218); +lean_ctor_set(x_219, 1, x_183); +if (lean_is_scalar(x_217)) { + x_220 = lean_alloc_ctor(0, 2, 0); +} else { + x_220 = x_217; + lean_ctor_set_tag(x_220, 0); +} +lean_ctor_set(x_220, 0, x_219); +lean_ctor_set(x_220, 1, x_216); +return x_220; +} +} +else +{ +lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; +x_221 = lean_ctor_get(x_206, 0); +lean_inc(x_221); +x_222 = lean_ctor_get(x_206, 1); +lean_inc(x_222); +if (lean_is_exclusive(x_206)) { + lean_ctor_release(x_206, 0); + lean_ctor_release(x_206, 1); + x_223 = x_206; +} else { + lean_dec_ref(x_206); + x_223 = lean_box(0); +} +x_224 = lean_io_error_to_string(x_221); +x_225 = l_Lake_print_x21___closed__8; +x_226 = lean_string_append(x_225, x_224); +lean_dec(x_224); +x_227 = lean_string_append(x_226, x_200); +x_228 = l_String_quote(x_205); +lean_dec(x_205); +x_229 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_229, 0, x_228); +x_230 = l_Std_Format_defWidth; +x_231 = lean_format_pretty(x_229, x_230, x_185, x_185); +x_232 = lean_string_append(x_227, x_231); +lean_dec(x_231); +x_233 = lean_string_append(x_232, x_187); +x_234 = l_Lake_print_x21___closed__11; +x_235 = l_Lake_print_x21___closed__12; +x_236 = lean_unsigned_to_nat(74u); +x_237 = lean_unsigned_to_nat(4u); +x_238 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_234, x_235, x_236, x_237, x_233); +lean_dec(x_233); +x_239 = l_panic___at_Lake_print_x21___spec__1(x_238, x_222); +if (lean_obj_tag(x_239) == 0) +{ +lean_object* x_240; lean_object* x_241; lean_object* x_242; +x_240 = lean_ctor_get(x_239, 1); +lean_inc(x_240); +lean_dec(x_239); +x_241 = lean_ctor_get(x_175, 0); +lean_inc(x_241); +lean_dec(x_175); +x_242 = lean_apply_1(x_241, x_240); +if (lean_obj_tag(x_242) == 0) +{ +lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; +x_243 = lean_ctor_get(x_242, 0); +lean_inc(x_243); +x_244 = lean_ctor_get(x_242, 1); +lean_inc(x_244); +if (lean_is_exclusive(x_242)) { + lean_ctor_release(x_242, 0); + lean_ctor_release(x_242, 1); + x_245 = x_242; +} else { + lean_dec_ref(x_242); + x_245 = lean_box(0); +} +if (lean_is_scalar(x_223)) { + x_246 = lean_alloc_ctor(0, 2, 0); +} else { + x_246 = x_223; + lean_ctor_set_tag(x_246, 0); +} +lean_ctor_set(x_246, 0, x_243); +lean_ctor_set(x_246, 1, x_183); +if (lean_is_scalar(x_245)) { + x_247 = lean_alloc_ctor(0, 2, 0); +} else { + x_247 = x_245; +} +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_244); +return x_247; +} +else +{ +lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; +x_248 = lean_ctor_get(x_242, 1); +lean_inc(x_248); +if (lean_is_exclusive(x_242)) { + lean_ctor_release(x_242, 0); + lean_ctor_release(x_242, 1); + x_249 = x_242; +} else { + lean_dec_ref(x_242); + x_249 = lean_box(0); +} +x_250 = lean_box(0); +if (lean_is_scalar(x_223)) { + x_251 = lean_alloc_ctor(0, 2, 0); +} else { + x_251 = x_223; + lean_ctor_set_tag(x_251, 0); +} +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_183); +if (lean_is_scalar(x_249)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_249; + lean_ctor_set_tag(x_252, 0); +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_248); +return x_252; +} +} +else +{ +lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; +lean_dec(x_223); +lean_dec(x_183); +lean_dec(x_175); +x_253 = lean_ctor_get(x_239, 0); +lean_inc(x_253); +x_254 = lean_ctor_get(x_239, 1); +lean_inc(x_254); +if (lean_is_exclusive(x_239)) { + lean_ctor_release(x_239, 0); + lean_ctor_release(x_239, 1); + x_255 = x_239; +} else { + lean_dec_ref(x_239); + x_255 = lean_box(0); +} +if (lean_is_scalar(x_255)) { + x_256 = lean_alloc_ctor(1, 2, 0); +} else { + x_256 = x_255; +} +lean_ctor_set(x_256, 0, x_253); +lean_ctor_set(x_256, 1, x_254); +return x_256; +} +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_renderProgress___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_Monitor_renderProgress(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_2); +lean_dec(x_1); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__1(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, size_t x_5, size_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; +x_11 = lean_usize_dec_eq(x_5, x_6); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; +lean_dec(x_7); +x_12 = lean_array_uget(x_4, x_5); +lean_inc(x_1); +x_13 = l_Lake_logToStream(x_12, x_1, x_2, x_3, x_10); +lean_dec(x_12); +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +lean_dec(x_13); +x_16 = 1; +x_17 = lean_usize_add(x_5, x_16); +x_5 = x_17; +x_7 = x_14; +x_10 = x_15; +goto _start; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_1); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_7); +lean_ctor_set(x_19, 1, x_9); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_10); +return x_20; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__2(lean_object* x_1, uint8_t x_2, lean_object* x_3, size_t x_4, size_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = lean_usize_dec_eq(x_4, x_5); +if (x_10 == 0) +{ +lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; +lean_dec(x_6); +x_11 = lean_array_uget(x_3, x_4); +x_12 = 0; +lean_inc(x_1); +x_13 = l_Lake_logToStream(x_11, x_1, x_12, x_2, x_9); +lean_dec(x_11); +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +lean_dec(x_13); +x_16 = 1; +x_17 = lean_usize_add(x_4, x_16); +x_4 = x_17; +x_6 = x_14; +x_9 = x_15; +goto _start; +} +else +{ +lean_object* x_19; lean_object* x_20; +lean_dec(x_1); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_6); +lean_ctor_set(x_19, 1, x_8); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_9); +return x_20; +} +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +lean_dec(x_2); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +lean_dec(x_5); +x_7 = lean_apply_1(x_6, x_4); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_7, 0); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_3); +lean_ctor_set(x_7, 0, x_10); +return x_7; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_7, 0); +x_12 = lean_ctor_get(x_7, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_7); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_3); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_12); +return x_14; +} +} +else +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_7); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_7, 0); +lean_dec(x_16); +x_17 = lean_box(0); +x_18 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set(x_18, 1, x_3); +lean_ctor_set_tag(x_7, 0); +lean_ctor_set(x_7, 0, x_18); +return x_7; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_19 = lean_ctor_get(x_7, 1); +lean_inc(x_19); +lean_dec(x_7); +x_20 = lean_box(0); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_20); +lean_ctor_set(x_21, 1, x_3); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_19); +return x_22; +} +} +} +} +static lean_object* _init_l_Lake_Monitor_reportJob___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Monitor_reportJob___lambda__1___boxed), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Monitor_reportJob___lambda__2___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("\n", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Monitor_reportJob___lambda__2___closed__3() { +_start: +{ +uint32_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 10004; +x_2 = l_Lake_print_x21___closed__10; +x_3 = lean_string_push(x_2, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_reportJob___lambda__2___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_print_x21___closed__10; +x_2 = l_Lake_Monitor_reportJob___lambda__2___closed__3; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_reportJob___lambda__2___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Monitor_reportJob___lambda__2___closed__4; +x_2 = l_Lake_Monitor_renderProgress___closed__2; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Monitor_reportJob___lambda__2___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" ", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Monitor_reportJob___lambda__2___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("32", 2); +return x_1; +} +} +static uint8_t _init_l_Lake_Monitor_reportJob___lambda__2___closed__8() { +_start: +{ +uint8_t x_1; uint8_t x_2; +x_1 = 0; +x_2 = l_instDecidableNot___rarg(x_1); +return x_2; +} +} +static uint8_t _init_l_Lake_Monitor_reportJob___lambda__2___closed__9() { +_start: +{ +uint8_t x_1; uint8_t x_2; +x_1 = 1; +x_2 = l_instDecidableNot___rarg(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__2(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, uint8_t x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, uint8_t x_9, uint8_t x_10, uint8_t x_11, uint8_t x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16) { +_start: +{ +lean_object* x_17; lean_object* x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; +x_17 = lean_array_get_size(x_1); +x_18 = lean_unsigned_to_nat(0u); +x_19 = lean_nat_dec_eq(x_17, x_18); +x_20 = l_instDecidableNot___rarg(x_19); +if (x_20 == 0) +{ +uint8_t x_297; +x_297 = 0; +x_21 = x_297; +goto block_296; +} +else +{ +uint8_t x_298; +x_298 = 1; +x_21 = x_298; +goto block_296; +} +block_296: +{ +uint8_t x_22; +if (x_21 == 0) +{ +uint8_t x_289; +x_289 = 0; +x_22 = x_289; +goto block_288; +} +else +{ +lean_object* x_290; lean_object* x_291; lean_object* x_292; uint8_t x_293; +x_290 = l_Lake_instOrdLogLevel; +x_291 = lean_box(x_12); +x_292 = lean_box(x_9); +x_293 = l_instDecidableRelLe___rarg(x_290, x_291, x_292); +if (x_293 == 0) +{ +uint8_t x_294; +x_294 = 0; +x_22 = x_294; +goto block_288; +} +else +{ +uint8_t x_295; +x_295 = 1; +x_22 = x_295; +goto block_288; +} +} +block_288: +{ +uint8_t x_23; +if (x_22 == 0) +{ +if (x_21 == 0) +{ +uint8_t x_280; +x_280 = 0; +x_23 = x_280; +goto block_279; +} +else +{ +lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; +x_281 = l_Lake_instOrdLogLevel; +x_282 = lean_box(x_3); +x_283 = lean_box(x_9); +x_284 = l_instDecidableRelLe___rarg(x_281, x_282, x_283); +if (x_284 == 0) +{ +uint8_t x_285; +x_285 = 0; +x_23 = x_285; +goto block_279; +} +else +{ +uint8_t x_286; +x_286 = 1; +x_23 = x_286; +goto block_279; +} +} +} +else +{ +uint8_t x_287; +x_287 = 1; +x_23 = x_287; +goto block_279; +} +block_279: +{ +lean_object* x_24; lean_object* x_212; +if (x_23 == 0) +{ +if (x_10 == 0) +{ +lean_object* x_251; lean_object* x_252; lean_object* x_253; +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +x_251 = lean_box(0); +x_252 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_15); +x_253 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_253, 0, x_252); +lean_ctor_set(x_253, 1, x_16); +return x_253; +} +else +{ +if (x_4 == 0) +{ +uint8_t x_254; +x_254 = l_Lake_Monitor_reportJob___lambda__2___closed__8; +if (x_254 == 0) +{ +lean_object* x_255; lean_object* x_256; lean_object* x_257; +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +x_255 = lean_box(0); +x_256 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_256, 0, x_255); +lean_ctor_set(x_256, 1, x_15); +x_257 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_257, 0, x_256); +lean_ctor_set(x_257, 1, x_16); +return x_257; +} +else +{ +lean_object* x_258; lean_object* x_259; lean_object* x_260; uint8_t x_261; +x_258 = l_Lake_instOrdJobAction; +x_259 = lean_box(x_11); +x_260 = lean_box(x_5); +x_261 = l_instDecidableRelLe___rarg(x_258, x_259, x_260); +if (x_261 == 0) +{ +lean_object* x_262; lean_object* x_263; lean_object* x_264; +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +x_262 = lean_box(0); +x_263 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_263, 0, x_262); +lean_ctor_set(x_263, 1, x_15); +x_264 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_264, 0, x_263); +lean_ctor_set(x_264, 1, x_16); +return x_264; +} +else +{ +lean_object* x_265; +x_265 = lean_box(0); +x_212 = x_265; +goto block_250; +} +} +} +else +{ +uint8_t x_266; +x_266 = l_Lake_Monitor_reportJob___lambda__2___closed__9; +if (x_266 == 0) +{ +lean_object* x_267; lean_object* x_268; lean_object* x_269; +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +x_267 = lean_box(0); +x_268 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_268, 0, x_267); +lean_ctor_set(x_268, 1, x_15); +x_269 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_269, 0, x_268); +lean_ctor_set(x_269, 1, x_16); +return x_269; +} +else +{ +lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; +x_270 = l_Lake_instOrdJobAction; +x_271 = lean_box(x_11); +x_272 = lean_box(x_5); +x_273 = l_instDecidableRelLe___rarg(x_270, x_271, x_272); +if (x_273 == 0) +{ +lean_object* x_274; lean_object* x_275; lean_object* x_276; +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +x_274 = lean_box(0); +x_275 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_275, 0, x_274); +lean_ctor_set(x_275, 1, x_15); +x_276 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_276, 0, x_275); +lean_ctor_set(x_276, 1, x_16); +return x_276; +} +else +{ +lean_object* x_277; +x_277 = lean_box(0); +x_212 = x_277; +goto block_250; +} +} +} +} +} +else +{ +lean_object* x_278; +x_278 = lean_box(0); +x_212 = x_278; +goto block_250; +} +block_211: +{ +uint8_t x_25; +x_25 = !lean_is_exclusive(x_15); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_26 = lean_ctor_get(x_15, 2); +x_27 = l_Lake_print_x21___closed__10; +lean_ctor_set(x_15, 2, x_27); +x_64 = lean_string_append(x_27, x_26); +lean_dec(x_26); +x_65 = lean_string_append(x_64, x_27); +x_66 = lean_string_append(x_65, x_24); +lean_dec(x_24); +x_67 = l_Lake_Monitor_reportJob___lambda__2___closed__2; +x_68 = lean_string_append(x_66, x_67); +x_69 = lean_ctor_get(x_14, 1); +lean_inc(x_69); +x_70 = lean_ctor_get(x_69, 4); +lean_inc(x_70); +lean_dec(x_69); +lean_inc(x_68); +x_71 = lean_apply_2(x_70, x_68, x_16); +if (lean_obj_tag(x_71) == 0) +{ +uint8_t x_72; +lean_dec(x_68); +x_72 = !lean_is_exclusive(x_71); +if (x_72 == 0) +{ +lean_object* x_73; +x_73 = lean_ctor_get(x_71, 1); +lean_ctor_set(x_71, 1, x_15); +x_28 = x_71; +x_29 = x_73; +goto block_63; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_71, 0); +x_75 = lean_ctor_get(x_71, 1); +lean_inc(x_75); +lean_inc(x_74); +lean_dec(x_71); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_15); +x_28 = x_76; +x_29 = x_75; +goto block_63; +} +} +else +{ +uint8_t x_77; +x_77 = !lean_is_exclusive(x_71); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_78 = lean_ctor_get(x_71, 0); +x_79 = lean_ctor_get(x_71, 1); +x_80 = lean_io_error_to_string(x_78); +x_81 = l_Lake_print_x21___closed__8; +x_82 = lean_string_append(x_81, x_80); +lean_dec(x_80); +x_83 = l_Lake_print_x21___closed__9; +x_84 = lean_string_append(x_82, x_83); +x_85 = l_String_quote(x_68); +lean_dec(x_68); +x_86 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_86, 0, x_85); +x_87 = l_Std_Format_defWidth; +x_88 = lean_format_pretty(x_86, x_87, x_18, x_18); +x_89 = lean_string_append(x_84, x_88); +lean_dec(x_88); +x_90 = lean_string_append(x_89, x_27); +x_91 = l_Lake_print_x21___closed__11; +x_92 = l_Lake_print_x21___closed__12; +x_93 = lean_unsigned_to_nat(74u); +x_94 = lean_unsigned_to_nat(4u); +x_95 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_91, x_92, x_93, x_94, x_90); +lean_dec(x_90); +x_96 = l_panic___at_Lake_print_x21___spec__1(x_95, x_79); +if (lean_obj_tag(x_96) == 0) +{ +lean_object* x_97; lean_object* x_98; +x_97 = lean_ctor_get(x_96, 0); +lean_inc(x_97); +x_98 = lean_ctor_get(x_96, 1); +lean_inc(x_98); +lean_dec(x_96); +lean_ctor_set_tag(x_71, 0); +lean_ctor_set(x_71, 1, x_15); +lean_ctor_set(x_71, 0, x_97); +x_28 = x_71; +x_29 = x_98; +goto block_63; +} +else +{ +uint8_t x_99; +lean_free_object(x_71); +lean_dec(x_15); +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_2); +x_99 = !lean_is_exclusive(x_96); +if (x_99 == 0) +{ +return x_96; +} +else +{ +lean_object* x_100; lean_object* x_101; lean_object* x_102; +x_100 = lean_ctor_get(x_96, 0); +x_101 = lean_ctor_get(x_96, 1); +lean_inc(x_101); +lean_inc(x_100); +lean_dec(x_96); +x_102 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_102, 0, x_100); +lean_ctor_set(x_102, 1, x_101); +return x_102; +} +} +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 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; +x_103 = lean_ctor_get(x_71, 0); +x_104 = lean_ctor_get(x_71, 1); +lean_inc(x_104); +lean_inc(x_103); +lean_dec(x_71); +x_105 = lean_io_error_to_string(x_103); +x_106 = l_Lake_print_x21___closed__8; +x_107 = lean_string_append(x_106, x_105); +lean_dec(x_105); +x_108 = l_Lake_print_x21___closed__9; +x_109 = lean_string_append(x_107, x_108); +x_110 = l_String_quote(x_68); +lean_dec(x_68); +x_111 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_111, 0, x_110); +x_112 = l_Std_Format_defWidth; +x_113 = lean_format_pretty(x_111, x_112, x_18, x_18); +x_114 = lean_string_append(x_109, x_113); +lean_dec(x_113); +x_115 = lean_string_append(x_114, x_27); +x_116 = l_Lake_print_x21___closed__11; +x_117 = l_Lake_print_x21___closed__12; +x_118 = lean_unsigned_to_nat(74u); +x_119 = lean_unsigned_to_nat(4u); +x_120 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_116, x_117, x_118, x_119, x_115); +lean_dec(x_115); +x_121 = l_panic___at_Lake_print_x21___spec__1(x_120, x_104); +if (lean_obj_tag(x_121) == 0) +{ +lean_object* x_122; lean_object* x_123; lean_object* x_124; +x_122 = lean_ctor_get(x_121, 0); +lean_inc(x_122); +x_123 = lean_ctor_get(x_121, 1); +lean_inc(x_123); +lean_dec(x_121); +x_124 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_124, 0, x_122); +lean_ctor_set(x_124, 1, x_15); +x_28 = x_124; +x_29 = x_123; +goto block_63; +} +else +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; +lean_dec(x_15); +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_2); +x_125 = lean_ctor_get(x_121, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_121, 1); +lean_inc(x_126); +if (lean_is_exclusive(x_121)) { + lean_ctor_release(x_121, 0); + lean_ctor_release(x_121, 1); + x_127 = x_121; +} else { + lean_dec_ref(x_121); + x_127 = lean_box(0); +} +if (lean_is_scalar(x_127)) { + x_128 = lean_alloc_ctor(1, 2, 0); +} else { + x_128 = x_127; +} +lean_ctor_set(x_128, 0, x_125); +lean_ctor_set(x_128, 1, x_126); +return x_128; +} +} +} +block_63: +{ +lean_object* x_30; lean_object* x_31; +x_30 = lean_ctor_get(x_28, 1); +lean_inc(x_30); +lean_dec(x_28); +x_31 = l_Lake_Monitor_reportJob___lambda__2___closed__1; +if (x_23 == 0) +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_17); +lean_dec(x_2); +x_32 = lean_box(0); +x_33 = lean_apply_4(x_31, x_32, x_14, x_30, x_29); +return x_33; +} +else +{ +uint8_t x_34; +x_34 = lean_nat_dec_lt(x_18, x_17); +if (x_22 == 0) +{ +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; +lean_dec(x_17); +lean_dec(x_2); +x_35 = lean_box(0); +x_36 = lean_apply_4(x_31, x_35, x_14, x_30, x_29); +return x_36; +} +else +{ +uint8_t x_37; +x_37 = lean_nat_dec_le(x_17, x_17); +if (x_37 == 0) +{ +lean_object* x_38; lean_object* x_39; +lean_dec(x_17); +lean_dec(x_2); +x_38 = lean_box(0); +x_39 = lean_apply_4(x_31, x_38, x_14, x_30, x_29); +return x_39; +} +else +{ +size_t x_40; size_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_40 = 0; +x_41 = lean_usize_of_nat(x_17); +lean_dec(x_17); +x_42 = lean_box(0); +x_43 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__1(x_2, x_3, x_4, x_1, x_40, x_41, x_42, x_14, x_30, x_29); +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_43, 1); +lean_inc(x_45); +lean_dec(x_43); +x_46 = lean_ctor_get(x_44, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_44, 1); +lean_inc(x_47); +lean_dec(x_44); +x_48 = lean_apply_4(x_31, x_46, x_14, x_47, x_45); +return x_48; +} +} +} +else +{ +if (x_34 == 0) +{ +lean_object* x_49; lean_object* x_50; +lean_dec(x_17); +lean_dec(x_2); +x_49 = lean_box(0); +x_50 = lean_apply_4(x_31, x_49, x_14, x_30, x_29); +return x_50; +} +else +{ +uint8_t x_51; +x_51 = lean_nat_dec_le(x_17, x_17); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; +lean_dec(x_17); +lean_dec(x_2); +x_52 = lean_box(0); +x_53 = lean_apply_4(x_31, x_52, x_14, x_30, x_29); +return x_53; +} +else +{ +size_t x_54; size_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_54 = 0; +x_55 = lean_usize_of_nat(x_17); +lean_dec(x_17); +x_56 = lean_box(0); +x_57 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__2(x_2, x_4, x_1, x_54, x_55, x_56, x_14, x_30, x_29); +x_58 = lean_ctor_get(x_57, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_57, 1); +lean_inc(x_59); +lean_dec(x_57); +x_60 = lean_ctor_get(x_58, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_58, 1); +lean_inc(x_61); +lean_dec(x_58); +x_62 = lean_apply_4(x_31, x_60, x_14, x_61, x_59); +return x_62; +} +} +} +} +} +} +else +{ +lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; +x_129 = lean_ctor_get(x_15, 0); +x_130 = lean_ctor_get(x_15, 1); +x_131 = lean_ctor_get(x_15, 2); +x_132 = lean_ctor_get(x_15, 3); +x_133 = lean_ctor_get(x_15, 4); +lean_inc(x_133); +lean_inc(x_132); +lean_inc(x_131); +lean_inc(x_130); +lean_inc(x_129); +lean_dec(x_15); +x_134 = l_Lake_print_x21___closed__10; +x_135 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_135, 0, x_129); +lean_ctor_set(x_135, 1, x_130); +lean_ctor_set(x_135, 2, x_134); +lean_ctor_set(x_135, 3, x_132); +lean_ctor_set(x_135, 4, x_133); +x_172 = lean_string_append(x_134, x_131); +lean_dec(x_131); +x_173 = lean_string_append(x_172, x_134); +x_174 = lean_string_append(x_173, x_24); +lean_dec(x_24); +x_175 = l_Lake_Monitor_reportJob___lambda__2___closed__2; +x_176 = lean_string_append(x_174, x_175); +x_177 = lean_ctor_get(x_14, 1); +lean_inc(x_177); +x_178 = lean_ctor_get(x_177, 4); +lean_inc(x_178); +lean_dec(x_177); +lean_inc(x_176); +x_179 = lean_apply_2(x_178, x_176, x_16); +if (lean_obj_tag(x_179) == 0) +{ +lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +lean_dec(x_176); +x_180 = lean_ctor_get(x_179, 0); +lean_inc(x_180); +x_181 = lean_ctor_get(x_179, 1); +lean_inc(x_181); +if (lean_is_exclusive(x_179)) { + lean_ctor_release(x_179, 0); + lean_ctor_release(x_179, 1); + x_182 = x_179; +} else { + lean_dec_ref(x_179); + x_182 = lean_box(0); +} +if (lean_is_scalar(x_182)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_182; +} +lean_ctor_set(x_183, 0, x_180); +lean_ctor_set(x_183, 1, x_135); +x_136 = x_183; +x_137 = x_181; +goto block_171; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +x_184 = lean_ctor_get(x_179, 0); +lean_inc(x_184); +x_185 = lean_ctor_get(x_179, 1); +lean_inc(x_185); +if (lean_is_exclusive(x_179)) { + lean_ctor_release(x_179, 0); + lean_ctor_release(x_179, 1); + x_186 = x_179; +} else { + lean_dec_ref(x_179); + x_186 = lean_box(0); +} +x_187 = lean_io_error_to_string(x_184); +x_188 = l_Lake_print_x21___closed__8; +x_189 = lean_string_append(x_188, x_187); +lean_dec(x_187); +x_190 = l_Lake_print_x21___closed__9; +x_191 = lean_string_append(x_189, x_190); +x_192 = l_String_quote(x_176); +lean_dec(x_176); +x_193 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_193, 0, x_192); +x_194 = l_Std_Format_defWidth; +x_195 = lean_format_pretty(x_193, x_194, x_18, x_18); +x_196 = lean_string_append(x_191, x_195); +lean_dec(x_195); +x_197 = lean_string_append(x_196, x_134); +x_198 = l_Lake_print_x21___closed__11; +x_199 = l_Lake_print_x21___closed__12; +x_200 = lean_unsigned_to_nat(74u); +x_201 = lean_unsigned_to_nat(4u); +x_202 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_198, x_199, x_200, x_201, x_197); +lean_dec(x_197); +x_203 = l_panic___at_Lake_print_x21___spec__1(x_202, x_185); +if (lean_obj_tag(x_203) == 0) +{ +lean_object* x_204; lean_object* x_205; lean_object* x_206; +x_204 = lean_ctor_get(x_203, 0); +lean_inc(x_204); +x_205 = lean_ctor_get(x_203, 1); +lean_inc(x_205); +lean_dec(x_203); +if (lean_is_scalar(x_186)) { + x_206 = lean_alloc_ctor(0, 2, 0); +} else { + x_206 = x_186; + lean_ctor_set_tag(x_206, 0); +} +lean_ctor_set(x_206, 0, x_204); +lean_ctor_set(x_206, 1, x_135); +x_136 = x_206; +x_137 = x_205; +goto block_171; +} +else +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +lean_dec(x_186); +lean_dec(x_135); +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_2); +x_207 = lean_ctor_get(x_203, 0); +lean_inc(x_207); +x_208 = lean_ctor_get(x_203, 1); +lean_inc(x_208); +if (lean_is_exclusive(x_203)) { + lean_ctor_release(x_203, 0); + lean_ctor_release(x_203, 1); + x_209 = x_203; +} else { + lean_dec_ref(x_203); + x_209 = lean_box(0); +} +if (lean_is_scalar(x_209)) { + x_210 = lean_alloc_ctor(1, 2, 0); +} else { + x_210 = x_209; +} +lean_ctor_set(x_210, 0, x_207); +lean_ctor_set(x_210, 1, x_208); +return x_210; +} +} +block_171: +{ +lean_object* x_138; lean_object* x_139; +x_138 = lean_ctor_get(x_136, 1); +lean_inc(x_138); +lean_dec(x_136); +x_139 = l_Lake_Monitor_reportJob___lambda__2___closed__1; +if (x_23 == 0) +{ +lean_object* x_140; lean_object* x_141; +lean_dec(x_17); +lean_dec(x_2); +x_140 = lean_box(0); +x_141 = lean_apply_4(x_139, x_140, x_14, x_138, x_137); +return x_141; +} +else +{ +uint8_t x_142; +x_142 = lean_nat_dec_lt(x_18, x_17); +if (x_22 == 0) +{ +if (x_142 == 0) +{ +lean_object* x_143; lean_object* x_144; +lean_dec(x_17); +lean_dec(x_2); +x_143 = lean_box(0); +x_144 = lean_apply_4(x_139, x_143, x_14, x_138, x_137); +return x_144; +} +else +{ +uint8_t x_145; +x_145 = lean_nat_dec_le(x_17, x_17); +if (x_145 == 0) +{ +lean_object* x_146; lean_object* x_147; +lean_dec(x_17); +lean_dec(x_2); +x_146 = lean_box(0); +x_147 = lean_apply_4(x_139, x_146, x_14, x_138, x_137); +return x_147; +} +else +{ +size_t x_148; size_t x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +x_148 = 0; +x_149 = lean_usize_of_nat(x_17); +lean_dec(x_17); +x_150 = lean_box(0); +x_151 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__1(x_2, x_3, x_4, x_1, x_148, x_149, x_150, x_14, x_138, x_137); +x_152 = lean_ctor_get(x_151, 0); +lean_inc(x_152); +x_153 = lean_ctor_get(x_151, 1); +lean_inc(x_153); +lean_dec(x_151); +x_154 = lean_ctor_get(x_152, 0); +lean_inc(x_154); +x_155 = lean_ctor_get(x_152, 1); +lean_inc(x_155); +lean_dec(x_152); +x_156 = lean_apply_4(x_139, x_154, x_14, x_155, x_153); +return x_156; +} +} +} +else +{ +if (x_142 == 0) +{ +lean_object* x_157; lean_object* x_158; +lean_dec(x_17); +lean_dec(x_2); +x_157 = lean_box(0); +x_158 = lean_apply_4(x_139, x_157, x_14, x_138, x_137); +return x_158; +} +else +{ +uint8_t x_159; +x_159 = lean_nat_dec_le(x_17, x_17); +if (x_159 == 0) +{ +lean_object* x_160; lean_object* x_161; +lean_dec(x_17); +lean_dec(x_2); +x_160 = lean_box(0); +x_161 = lean_apply_4(x_139, x_160, x_14, x_138, x_137); +return x_161; +} +else +{ +size_t x_162; size_t x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_162 = 0; +x_163 = lean_usize_of_nat(x_17); +lean_dec(x_17); +x_164 = lean_box(0); +x_165 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__2(x_2, x_4, x_1, x_162, x_163, x_164, x_14, x_138, x_137); +x_166 = lean_ctor_get(x_165, 0); +lean_inc(x_166); +x_167 = lean_ctor_get(x_165, 1); +lean_inc(x_167); +lean_dec(x_165); +x_168 = lean_ctor_get(x_166, 0); +lean_inc(x_168); +x_169 = lean_ctor_get(x_166, 1); +lean_inc(x_169); +lean_dec(x_166); +x_170 = lean_apply_4(x_139, x_168, x_14, x_169, x_167); +return x_170; +} +} +} +} +} +} +} +block_250: +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; +lean_dec(x_212); +x_213 = l_Lake_JobAction_verb(x_22, x_5); +x_214 = l___private_Init_Data_Repr_0__Nat_reprFast(x_6); +x_215 = l___private_Init_Data_Repr_0__Nat_reprFast(x_7); +if (x_23 == 0) +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; +x_216 = l_Lake_Monitor_reportJob___lambda__2___closed__5; +x_217 = lean_string_append(x_216, x_214); +lean_dec(x_214); +x_218 = l_Lake_Monitor_renderProgress___closed__3; +x_219 = lean_string_append(x_217, x_218); +x_220 = lean_string_append(x_219, x_215); +lean_dec(x_215); +x_221 = l_Lake_print_x21___closed__9; +x_222 = lean_string_append(x_220, x_221); +x_223 = lean_string_append(x_222, x_213); +lean_dec(x_213); +x_224 = l_Lake_Monitor_reportJob___lambda__2___closed__6; +x_225 = lean_string_append(x_223, x_224); +x_226 = lean_string_append(x_225, x_8); +x_227 = l_Lake_print_x21___closed__10; +x_228 = lean_string_append(x_226, x_227); +if (x_4 == 0) +{ +x_24 = x_228; +goto block_211; +} +else +{ +lean_object* x_229; lean_object* x_230; +x_229 = l_Lake_Monitor_reportJob___lambda__2___closed__7; +x_230 = l_Lake_Ansi_chalk(x_229, x_228); +lean_dec(x_228); +x_24 = x_230; +goto block_211; +} +} +else +{ +uint32_t x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; +x_231 = l_Lake_LogLevel_icon(x_9); +x_232 = l_Lake_print_x21___closed__10; +x_233 = lean_string_push(x_232, x_231); +x_234 = lean_string_append(x_232, x_233); +lean_dec(x_233); +x_235 = l_Lake_Monitor_renderProgress___closed__2; +x_236 = lean_string_append(x_234, x_235); +x_237 = lean_string_append(x_236, x_214); +lean_dec(x_214); +x_238 = l_Lake_Monitor_renderProgress___closed__3; +x_239 = lean_string_append(x_237, x_238); +x_240 = lean_string_append(x_239, x_215); +lean_dec(x_215); +x_241 = l_Lake_print_x21___closed__9; +x_242 = lean_string_append(x_240, x_241); +x_243 = lean_string_append(x_242, x_213); +lean_dec(x_213); +x_244 = l_Lake_Monitor_reportJob___lambda__2___closed__6; +x_245 = lean_string_append(x_243, x_244); +x_246 = lean_string_append(x_245, x_8); +x_247 = lean_string_append(x_246, x_232); +if (x_4 == 0) +{ +x_24 = x_247; +goto block_211; +} +else +{ +lean_object* x_248; lean_object* x_249; +x_248 = l_Lake_LogLevel_ansiColor(x_9); +x_249 = l_Lake_Ansi_chalk(x_248, x_247); +lean_dec(x_247); +lean_dec(x_248); +x_24 = x_249; +goto block_211; +} +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; uint8_t x_13; uint8_t x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_3, 1); +lean_inc(x_6); +x_7 = lean_ctor_get(x_3, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_3, 3); +lean_inc(x_8); +x_9 = lean_ctor_get(x_3, 4); +lean_inc(x_9); +x_10 = lean_ctor_get(x_2, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_2, 1); +lean_inc(x_11); +x_12 = lean_ctor_get_uint8(x_2, sizeof(void*)*3); +x_13 = lean_ctor_get_uint8(x_2, sizeof(void*)*3 + 1); +x_14 = lean_ctor_get_uint8(x_2, sizeof(void*)*3 + 2); +x_15 = lean_ctor_get_uint8(x_2, sizeof(void*)*3 + 3); +x_16 = lean_ctor_get_uint8(x_2, sizeof(void*)*3 + 4); +x_17 = lean_ctor_get(x_1, 0); +lean_inc(x_17); +x_18 = lean_ctor_get(x_1, 1); +lean_inc(x_18); +lean_dec(x_1); +x_48 = lean_task_get_own(x_17); +x_49 = lean_ctor_get(x_48, 1); +lean_inc(x_49); +lean_dec(x_48); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +x_51 = lean_ctor_get_uint8(x_49, sizeof(void*)*1); +lean_dec(x_49); +x_19 = x_50; +x_20 = x_51; +goto block_47; +block_47: +{ +uint8_t x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; uint8_t x_25; +x_21 = l_Lake_Log_maxLv(x_19); +x_22 = lean_array_get_size(x_19); +x_23 = lean_unsigned_to_nat(0u); +x_24 = lean_nat_dec_eq(x_22, x_23); +lean_dec(x_22); +x_25 = l_instDecidableNot___rarg(x_24); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_26 = lean_box(0); +x_27 = l_Lake_Monitor_reportJob___lambda__2(x_19, x_11, x_12, x_15, x_20, x_5, x_10, x_18, x_21, x_16, x_14, x_13, x_26, x_2, x_3, x_4); +lean_dec(x_18); +lean_dec(x_19); +return x_27; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_28 = l_Lake_instOrdLogLevel; +x_29 = lean_box(x_13); +x_30 = lean_box(x_21); +x_31 = l_instDecidableRelLe___rarg(x_28, x_29, x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +x_32 = lean_box(0); +x_33 = l_Lake_Monitor_reportJob___lambda__2(x_19, x_11, x_12, x_15, x_20, x_5, x_10, x_18, x_21, x_16, x_14, x_13, x_32, x_2, x_3, x_4); +lean_dec(x_18); +lean_dec(x_19); +return x_33; +} +else +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_3); +if (x_34 == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_35 = lean_ctor_get(x_3, 4); +lean_dec(x_35); +x_36 = lean_ctor_get(x_3, 3); +lean_dec(x_36); +x_37 = lean_ctor_get(x_3, 2); +lean_dec(x_37); +x_38 = lean_ctor_get(x_3, 1); +lean_dec(x_38); +x_39 = lean_ctor_get(x_3, 0); +lean_dec(x_39); +lean_inc(x_18); +x_40 = lean_array_push(x_6, x_18); +lean_inc(x_5); +lean_ctor_set(x_3, 1, x_40); +x_41 = lean_box(0); +x_42 = l_Lake_Monitor_reportJob___lambda__2(x_19, x_11, x_12, x_15, x_20, x_5, x_10, x_18, x_21, x_16, x_14, x_13, x_41, x_2, x_3, x_4); +lean_dec(x_18); +lean_dec(x_19); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_dec(x_3); +lean_inc(x_18); +x_43 = lean_array_push(x_6, x_18); +lean_inc(x_5); +x_44 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_44, 0, x_5); +lean_ctor_set(x_44, 1, x_43); +lean_ctor_set(x_44, 2, x_7); +lean_ctor_set(x_44, 3, x_8); +lean_ctor_set(x_44, 4, x_9); +x_45 = lean_box(0); +x_46 = l_Lake_Monitor_reportJob___lambda__2(x_19, x_11, x_12, x_15, x_20, x_5, x_10, x_18, x_21, x_16, x_14, x_13, x_45, x_2, x_44, x_4); +lean_dec(x_18); +lean_dec(x_19); +return x_46; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; uint8_t x_12; size_t x_13; size_t x_14; lean_object* x_15; +x_11 = lean_unbox(x_2); +lean_dec(x_2); +x_12 = lean_unbox(x_3); +lean_dec(x_3); +x_13 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_14 = lean_unbox_usize(x_6); +lean_dec(x_6); +x_15 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__1(x_1, x_11, x_12, x_4, x_13, x_14, x_7, x_8, x_9, x_10); +lean_dec(x_8); +lean_dec(x_4); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; size_t x_11; size_t x_12; lean_object* x_13; +x_10 = lean_unbox(x_2); +lean_dec(x_2); +x_11 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_12 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_reportJob___spec__2(x_1, x_10, x_3, x_11, x_12, x_6, x_7, x_8, x_9); +lean_dec(x_7); +lean_dec(x_3); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Monitor_reportJob___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_reportJob___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16) { +_start: +{ +uint8_t x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; lean_object* x_24; +x_17 = lean_unbox(x_3); +lean_dec(x_3); +x_18 = lean_unbox(x_4); +lean_dec(x_4); +x_19 = lean_unbox(x_5); +lean_dec(x_5); +x_20 = lean_unbox(x_9); +lean_dec(x_9); +x_21 = lean_unbox(x_10); +lean_dec(x_10); +x_22 = lean_unbox(x_11); +lean_dec(x_11); +x_23 = lean_unbox(x_12); +lean_dec(x_12); +x_24 = l_Lake_Monitor_reportJob___lambda__2(x_1, x_2, x_17, x_18, x_19, x_6, x_7, x_8, x_20, x_21, x_22, x_23, x_13, x_14, x_15, x_16); +lean_dec(x_13); +lean_dec(x_8); +lean_dec(x_1); +return x_24; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_poll___spec__1(lean_object* x_1, size_t x_2, size_t x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = lean_usize_dec_eq(x_2, x_3); +if (x_8 == 0) +{ +lean_object* x_9; uint8_t x_10; +x_9 = lean_array_uget(x_1, x_2); +x_10 = !lean_is_exclusive(x_4); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_11 = lean_ctor_get(x_4, 0); +x_12 = lean_ctor_get(x_4, 1); +x_13 = lean_ctor_get(x_9, 0); +lean_inc(x_13); +x_14 = lean_io_get_task_state(x_13, x_7); +lean_dec(x_13); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_unbox(x_15); +lean_dec(x_15); +switch (x_16) { +case 0: +{ +lean_object* x_17; lean_object* x_18; size_t x_19; size_t x_20; +x_17 = lean_ctor_get(x_14, 1); +lean_inc(x_17); +lean_dec(x_14); +x_18 = lean_array_push(x_12, x_9); +lean_ctor_set(x_4, 1, x_18); +x_19 = 1; +x_20 = lean_usize_add(x_2, x_19); +x_2 = x_20; +x_7 = x_17; +goto _start; +} +case 1: +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; size_t x_25; size_t x_26; +x_22 = lean_ctor_get(x_14, 1); +lean_inc(x_22); +lean_dec(x_14); +lean_inc(x_9); +x_23 = lean_array_push(x_11, x_9); +x_24 = lean_array_push(x_12, x_9); +lean_ctor_set(x_4, 1, x_24); +lean_ctor_set(x_4, 0, x_23); +x_25 = 1; +x_26 = lean_usize_add(x_2, x_25); +x_2 = x_26; +x_7 = x_22; +goto _start; +} +default: +{ +lean_object* x_28; lean_object* x_29; +lean_free_object(x_4); +x_28 = lean_ctor_get(x_14, 1); +lean_inc(x_28); +lean_dec(x_14); +lean_inc(x_5); +x_29 = l_Lake_Monitor_reportJob(x_9, x_5, x_6, x_28); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_29, 0); +lean_inc(x_30); +x_31 = !lean_is_exclusive(x_30); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; +x_32 = lean_ctor_get(x_30, 1); +x_33 = lean_ctor_get(x_30, 0); +lean_dec(x_33); +x_34 = lean_ctor_get(x_29, 1); +lean_inc(x_34); +lean_dec(x_29); +x_35 = !lean_is_exclusive(x_32); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; size_t x_39; size_t x_40; +x_36 = lean_ctor_get(x_32, 0); +x_37 = lean_unsigned_to_nat(1u); +x_38 = lean_nat_add(x_36, x_37); +lean_dec(x_36); +lean_ctor_set(x_32, 0, x_38); +lean_ctor_set(x_30, 1, x_12); +lean_ctor_set(x_30, 0, x_11); +x_39 = 1; +x_40 = lean_usize_add(x_2, x_39); +x_2 = x_40; +x_4 = x_30; +x_6 = x_32; +x_7 = x_34; +goto _start; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; size_t x_50; size_t x_51; +x_42 = lean_ctor_get(x_32, 0); +x_43 = lean_ctor_get(x_32, 1); +x_44 = lean_ctor_get(x_32, 2); +x_45 = lean_ctor_get(x_32, 3); +x_46 = lean_ctor_get(x_32, 4); +lean_inc(x_46); +lean_inc(x_45); +lean_inc(x_44); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_32); +x_47 = lean_unsigned_to_nat(1u); +x_48 = lean_nat_add(x_42, x_47); +lean_dec(x_42); +x_49 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_43); +lean_ctor_set(x_49, 2, x_44); +lean_ctor_set(x_49, 3, x_45); +lean_ctor_set(x_49, 4, x_46); +lean_ctor_set(x_30, 1, x_12); +lean_ctor_set(x_30, 0, x_11); +x_50 = 1; +x_51 = lean_usize_add(x_2, x_50); +x_2 = x_51; +x_4 = x_30; +x_6 = x_49; +x_7 = x_34; +goto _start; +} +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; size_t x_65; size_t x_66; +x_53 = lean_ctor_get(x_30, 1); +lean_inc(x_53); +lean_dec(x_30); +x_54 = lean_ctor_get(x_29, 1); +lean_inc(x_54); +lean_dec(x_29); +x_55 = lean_ctor_get(x_53, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_53, 1); +lean_inc(x_56); +x_57 = lean_ctor_get(x_53, 2); +lean_inc(x_57); +x_58 = lean_ctor_get(x_53, 3); +lean_inc(x_58); +x_59 = lean_ctor_get(x_53, 4); +lean_inc(x_59); +if (lean_is_exclusive(x_53)) { + lean_ctor_release(x_53, 0); + lean_ctor_release(x_53, 1); + lean_ctor_release(x_53, 2); + lean_ctor_release(x_53, 3); + lean_ctor_release(x_53, 4); + x_60 = x_53; +} else { + lean_dec_ref(x_53); + x_60 = lean_box(0); +} +x_61 = lean_unsigned_to_nat(1u); +x_62 = lean_nat_add(x_55, x_61); +lean_dec(x_55); +if (lean_is_scalar(x_60)) { + x_63 = lean_alloc_ctor(0, 5, 0); +} else { + x_63 = x_60; +} +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_56); +lean_ctor_set(x_63, 2, x_57); +lean_ctor_set(x_63, 3, x_58); +lean_ctor_set(x_63, 4, x_59); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_11); +lean_ctor_set(x_64, 1, x_12); +x_65 = 1; +x_66 = lean_usize_add(x_2, x_65); +x_2 = x_66; +x_4 = x_64; +x_6 = x_63; +x_7 = x_54; +goto _start; +} +} +else +{ +uint8_t x_68; +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_5); +x_68 = !lean_is_exclusive(x_29); +if (x_68 == 0) +{ +return x_29; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_29, 0); +x_70 = lean_ctor_get(x_29, 1); +lean_inc(x_70); +lean_inc(x_69); +lean_dec(x_29); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_69); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +} +} +} +} +else +{ +uint8_t x_72; +lean_free_object(x_4); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_72 = !lean_is_exclusive(x_14); +if (x_72 == 0) +{ +return x_14; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_73 = lean_ctor_get(x_14, 0); +x_74 = lean_ctor_get(x_14, 1); +lean_inc(x_74); +lean_inc(x_73); +lean_dec(x_14); +x_75 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_75, 0, x_73); +lean_ctor_set(x_75, 1, x_74); +return x_75; +} +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_76 = lean_ctor_get(x_4, 0); +x_77 = lean_ctor_get(x_4, 1); +lean_inc(x_77); +lean_inc(x_76); +lean_dec(x_4); +x_78 = lean_ctor_get(x_9, 0); +lean_inc(x_78); +x_79 = lean_io_get_task_state(x_78, x_7); +lean_dec(x_78); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; uint8_t x_81; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_unbox(x_80); +lean_dec(x_80); +switch (x_81) { +case 0: +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; size_t x_85; size_t x_86; +x_82 = lean_ctor_get(x_79, 1); +lean_inc(x_82); +lean_dec(x_79); +x_83 = lean_array_push(x_77, x_9); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_76); +lean_ctor_set(x_84, 1, x_83); +x_85 = 1; +x_86 = lean_usize_add(x_2, x_85); +x_2 = x_86; +x_4 = x_84; +x_7 = x_82; +goto _start; +} +case 1: +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; size_t x_92; size_t x_93; +x_88 = lean_ctor_get(x_79, 1); +lean_inc(x_88); +lean_dec(x_79); +lean_inc(x_9); +x_89 = lean_array_push(x_76, x_9); +x_90 = lean_array_push(x_77, x_9); +x_91 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set(x_91, 1, x_90); +x_92 = 1; +x_93 = lean_usize_add(x_2, x_92); +x_2 = x_93; +x_4 = x_91; +x_7 = x_88; +goto _start; +} +default: +{ +lean_object* x_95; lean_object* x_96; +x_95 = lean_ctor_get(x_79, 1); +lean_inc(x_95); +lean_dec(x_79); +lean_inc(x_5); +x_96 = l_Lake_Monitor_reportJob(x_9, x_5, x_6, x_95); +if (lean_obj_tag(x_96) == 0) +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; 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; size_t x_111; size_t x_112; +x_97 = lean_ctor_get(x_96, 0); +lean_inc(x_97); +x_98 = lean_ctor_get(x_97, 1); +lean_inc(x_98); +if (lean_is_exclusive(x_97)) { + lean_ctor_release(x_97, 0); + lean_ctor_release(x_97, 1); + x_99 = x_97; +} else { + lean_dec_ref(x_97); + x_99 = lean_box(0); +} +x_100 = lean_ctor_get(x_96, 1); +lean_inc(x_100); +lean_dec(x_96); +x_101 = lean_ctor_get(x_98, 0); +lean_inc(x_101); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +x_103 = lean_ctor_get(x_98, 2); +lean_inc(x_103); +x_104 = lean_ctor_get(x_98, 3); +lean_inc(x_104); +x_105 = lean_ctor_get(x_98, 4); +lean_inc(x_105); +if (lean_is_exclusive(x_98)) { + lean_ctor_release(x_98, 0); + lean_ctor_release(x_98, 1); + lean_ctor_release(x_98, 2); + lean_ctor_release(x_98, 3); + lean_ctor_release(x_98, 4); + x_106 = x_98; +} else { + lean_dec_ref(x_98); + x_106 = lean_box(0); +} +x_107 = lean_unsigned_to_nat(1u); +x_108 = lean_nat_add(x_101, x_107); +lean_dec(x_101); +if (lean_is_scalar(x_106)) { + x_109 = lean_alloc_ctor(0, 5, 0); +} else { + x_109 = x_106; +} +lean_ctor_set(x_109, 0, x_108); +lean_ctor_set(x_109, 1, x_102); +lean_ctor_set(x_109, 2, x_103); +lean_ctor_set(x_109, 3, x_104); +lean_ctor_set(x_109, 4, x_105); +if (lean_is_scalar(x_99)) { + x_110 = lean_alloc_ctor(0, 2, 0); +} else { + x_110 = x_99; +} +lean_ctor_set(x_110, 0, x_76); +lean_ctor_set(x_110, 1, x_77); +x_111 = 1; +x_112 = lean_usize_add(x_2, x_111); +x_2 = x_112; +x_4 = x_110; +x_6 = x_109; +x_7 = x_100; +goto _start; +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +lean_dec(x_77); +lean_dec(x_76); +lean_dec(x_5); +x_114 = lean_ctor_get(x_96, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_96, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_96)) { + lean_ctor_release(x_96, 0); + lean_ctor_release(x_96, 1); + x_116 = x_96; +} else { + lean_dec_ref(x_96); + x_116 = lean_box(0); +} +if (lean_is_scalar(x_116)) { + x_117 = lean_alloc_ctor(1, 2, 0); +} else { + x_117 = x_116; +} +lean_ctor_set(x_117, 0, x_114); +lean_ctor_set(x_117, 1, x_115); +return x_117; +} +} +} +} +else +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; +lean_dec(x_77); +lean_dec(x_76); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_5); +x_118 = lean_ctor_get(x_79, 0); +lean_inc(x_118); +x_119 = lean_ctor_get(x_79, 1); +lean_inc(x_119); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_120 = x_79; +} else { + lean_dec_ref(x_79); + x_120 = lean_box(0); +} +if (lean_is_scalar(x_120)) { + x_121 = lean_alloc_ctor(1, 2, 0); +} else { + x_121 = x_120; +} +lean_ctor_set(x_121, 0, x_118); +lean_ctor_set(x_121, 1, x_119); +return x_121; +} +} +} +else +{ +lean_object* x_122; lean_object* x_123; +lean_dec(x_5); +x_122 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_122, 0, x_4); +lean_ctor_set(x_122, 1, x_6); +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_122); +lean_ctor_set(x_123, 1, x_7); +return x_123; +} +} +} +static lean_object* _init_l_Lake_Monitor_poll___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_mkBuildContext___closed__1; +x_2 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_2, 0, x_1); +lean_ctor_set(x_2, 1, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_poll(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; uint8_t x_7; +x_5 = lean_array_get_size(x_1); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_nat_dec_lt(x_6, x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_dec(x_5); +lean_dec(x_2); +x_8 = l_Lake_Monitor_poll___closed__1; +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_3); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_4); +return x_10; +} +else +{ +uint8_t x_11; +x_11 = lean_nat_dec_le(x_5, x_5); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_5); +lean_dec(x_2); +x_12 = l_Lake_Monitor_poll___closed__1; +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_3); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_4); +return x_14; +} +else +{ +size_t x_15; size_t x_16; lean_object* x_17; lean_object* x_18; +x_15 = 0; +x_16 = lean_usize_of_nat(x_5); +lean_dec(x_5); +x_17 = l_Lake_Monitor_poll___closed__1; +x_18 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_poll___spec__1(x_1, x_15, x_16, x_17, x_2, x_3, x_4); +return x_18; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Monitor_poll___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +size_t x_8; size_t x_9; lean_object* x_10; +x_8 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_9 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_10 = l_Array_foldlMUnsafe_fold___at_Lake_Monitor_poll___spec__1(x_1, x_8, x_9, x_4, x_5, x_6, x_7); +lean_dec(x_1); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_poll___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Monitor_poll(x_1, x_2, x_3, x_4); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_sleep___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_io_mono_ms_now(x_4); +if (lean_obj_tag(x_5) == 0) +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +uint8_t x_7; +x_7 = !lean_is_exclusive(x_3); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_ctor_get(x_5, 0); +x_9 = lean_ctor_get(x_3, 3); +lean_dec(x_9); +lean_ctor_set(x_3, 3, x_8); +x_10 = lean_box(0); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_3); +lean_ctor_set(x_5, 0, x_11); +return x_5; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_12 = lean_ctor_get(x_5, 0); +x_13 = lean_ctor_get(x_3, 0); +x_14 = lean_ctor_get(x_3, 1); +x_15 = lean_ctor_get(x_3, 2); +x_16 = lean_ctor_get(x_3, 4); +lean_inc(x_16); +lean_inc(x_15); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_3); +x_17 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_17, 0, x_13); +lean_ctor_set(x_17, 1, x_14); +lean_ctor_set(x_17, 2, x_15); +lean_ctor_set(x_17, 3, x_12); +lean_ctor_set(x_17, 4, x_16); +x_18 = lean_box(0); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_17); +lean_ctor_set(x_5, 0, x_19); +return x_5; +} +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_20 = lean_ctor_get(x_5, 0); +x_21 = lean_ctor_get(x_5, 1); +lean_inc(x_21); +lean_inc(x_20); +lean_dec(x_5); +x_22 = lean_ctor_get(x_3, 0); +lean_inc(x_22); +x_23 = lean_ctor_get(x_3, 1); +lean_inc(x_23); +x_24 = lean_ctor_get(x_3, 2); +lean_inc(x_24); +x_25 = lean_ctor_get(x_3, 4); +lean_inc(x_25); +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); + x_26 = x_3; +} else { + lean_dec_ref(x_3); + x_26 = lean_box(0); +} +if (lean_is_scalar(x_26)) { + x_27 = lean_alloc_ctor(0, 5, 0); +} else { + x_27 = x_26; +} +lean_ctor_set(x_27, 0, x_22); +lean_ctor_set(x_27, 1, x_23); +lean_ctor_set(x_27, 2, x_24); +lean_ctor_set(x_27, 3, x_20); +lean_ctor_set(x_27, 4, x_25); +x_28 = lean_box(0); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_21); +return x_30; +} +} +else +{ +uint8_t x_31; +lean_dec(x_3); +x_31 = !lean_is_exclusive(x_5); +if (x_31 == 0) +{ +return x_5; +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_5, 0); +x_33 = lean_ctor_get(x_5, 1); +lean_inc(x_33); +lean_inc(x_32); +lean_dec(x_5); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +return x_34; +} +} +} +} +static lean_object* _init_l_Lake_Monitor_sleep___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Monitor_sleep___lambda__1___boxed), 4, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_sleep(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_io_mono_ms_now(x_3); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_5 = lean_ctor_get(x_4, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_4, 1); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_ctor_get(x_2, 3); +lean_inc(x_7); +x_8 = lean_ctor_get(x_1, 2); +lean_inc(x_8); +x_9 = lean_nat_sub(x_5, x_7); +lean_dec(x_7); +lean_dec(x_5); +x_10 = lean_nat_sub(x_8, x_9); +lean_dec(x_9); +lean_dec(x_8); +x_11 = l_Lake_Monitor_sleep___closed__1; +x_12 = lean_unsigned_to_nat(0u); +x_13 = lean_nat_dec_lt(x_12, x_10); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; +lean_dec(x_10); +x_14 = lean_box(0); +x_15 = lean_apply_4(x_11, x_14, x_1, x_2, x_6); +return x_15; +} +else +{ +uint32_t x_16; lean_object* x_17; +x_16 = lean_uint32_of_nat(x_10); +lean_dec(x_10); +x_17 = l_IO_sleep(x_16, x_6); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_17, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_17, 1); +lean_inc(x_19); +lean_dec(x_17); +x_20 = lean_apply_4(x_11, x_18, x_1, x_2, x_19); +return x_20; +} +else +{ +uint8_t x_21; +lean_dec(x_2); +lean_dec(x_1); +x_21 = !lean_is_exclusive(x_17); +if (x_21 == 0) +{ +return x_17; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_17, 0); +x_23 = lean_ctor_get(x_17, 1); +lean_inc(x_23); +lean_inc(x_22); +lean_dec(x_17); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set(x_24, 1, x_23); +return x_24; +} +} +} +} +else +{ +uint8_t x_25; +lean_dec(x_2); +lean_dec(x_1); +x_25 = !lean_is_exclusive(x_4); +if (x_25 == 0) +{ +return x_4; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_4, 0); +x_27 = lean_ctor_get(x_4, 1); +lean_inc(x_27); +lean_inc(x_26); +lean_dec(x_4); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +return x_28; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_sleep___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Monitor_sleep___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_loop(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +lean_inc(x_2); +x_5 = l_Lake_Monitor_poll(x_1, x_2, x_3, x_4); +lean_dec(x_1); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = !lean_is_exclusive(x_5); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_9 = lean_ctor_get(x_5, 1); +x_10 = lean_ctor_get(x_5, 0); +lean_dec(x_10); +x_11 = lean_ctor_get(x_6, 1); +lean_inc(x_11); +lean_dec(x_6); +x_12 = !lean_is_exclusive(x_7); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; +x_13 = lean_ctor_get(x_7, 0); +x_14 = lean_ctor_get(x_7, 1); +x_15 = lean_array_get_size(x_14); +x_16 = lean_unsigned_to_nat(0u); +x_17 = lean_nat_dec_lt(x_16, x_15); +lean_dec(x_15); +if (x_17 == 0) +{ +lean_object* x_18; +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_2); +x_18 = lean_box(0); +lean_ctor_set(x_7, 1, x_11); +lean_ctor_set(x_7, 0, x_18); +lean_ctor_set(x_5, 0, x_7); +return x_5; +} +else +{ +lean_object* x_19; +lean_free_object(x_7); +lean_free_object(x_5); +lean_inc(x_2); +x_19 = l_Lake_Monitor_renderProgress(x_13, x_14, lean_box(0), x_2, x_11, x_9); +lean_dec(x_13); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_19, 1); +lean_inc(x_21); +lean_dec(x_19); +x_22 = lean_ctor_get(x_20, 1); +lean_inc(x_22); +lean_dec(x_20); +lean_inc(x_2); +x_23 = l_Lake_Monitor_sleep(x_2, x_22, x_21); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_23, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_23, 1); +lean_inc(x_25); +lean_dec(x_23); +x_26 = lean_ctor_get(x_24, 1); +lean_inc(x_26); +lean_dec(x_24); +x_1 = x_14; +x_3 = x_26; +x_4 = x_25; +goto _start; +} +else +{ +uint8_t x_28; +lean_dec(x_14); +lean_dec(x_2); +x_28 = !lean_is_exclusive(x_23); +if (x_28 == 0) +{ +return x_23; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_23, 0); +x_30 = lean_ctor_get(x_23, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_23); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +return x_31; +} +} +} +else +{ +uint8_t x_32; +lean_dec(x_14); +lean_dec(x_2); +x_32 = !lean_is_exclusive(x_19); +if (x_32 == 0) +{ +return x_19; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_19, 0); +x_34 = lean_ctor_get(x_19, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_19); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +return x_35; +} +} +} +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; +x_36 = lean_ctor_get(x_7, 0); +x_37 = lean_ctor_get(x_7, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_7); +x_38 = lean_array_get_size(x_37); +x_39 = lean_unsigned_to_nat(0u); +x_40 = lean_nat_dec_lt(x_39, x_38); +lean_dec(x_38); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +lean_dec(x_37); +lean_dec(x_36); +lean_dec(x_2); +x_41 = lean_box(0); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_11); +lean_ctor_set(x_5, 0, x_42); +return x_5; +} +else +{ +lean_object* x_43; +lean_free_object(x_5); +lean_inc(x_2); +x_43 = l_Lake_Monitor_renderProgress(x_36, x_37, lean_box(0), x_2, x_11, x_9); +lean_dec(x_36); +if (lean_obj_tag(x_43) == 0) +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_43, 1); +lean_inc(x_45); +lean_dec(x_43); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +lean_inc(x_2); +x_47 = l_Lake_Monitor_sleep(x_2, x_46, x_45); +if (lean_obj_tag(x_47) == 0) +{ +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_47, 1); +lean_inc(x_49); +lean_dec(x_47); +x_50 = lean_ctor_get(x_48, 1); +lean_inc(x_50); +lean_dec(x_48); +x_1 = x_37; +x_3 = x_50; +x_4 = x_49; +goto _start; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +lean_dec(x_37); +lean_dec(x_2); +x_52 = lean_ctor_get(x_47, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_47, 1); +lean_inc(x_53); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_54 = x_47; +} else { + lean_dec_ref(x_47); + x_54 = lean_box(0); +} +if (lean_is_scalar(x_54)) { + x_55 = lean_alloc_ctor(1, 2, 0); +} else { + x_55 = x_54; +} +lean_ctor_set(x_55, 0, x_52); +lean_ctor_set(x_55, 1, x_53); +return x_55; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +lean_dec(x_37); +lean_dec(x_2); +x_56 = lean_ctor_get(x_43, 0); +lean_inc(x_56); +x_57 = lean_ctor_get(x_43, 1); +lean_inc(x_57); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_58 = x_43; +} else { + lean_dec_ref(x_43); + x_58 = lean_box(0); +} +if (lean_is_scalar(x_58)) { + x_59 = lean_alloc_ctor(1, 2, 0); +} else { + x_59 = x_58; +} +lean_ctor_set(x_59, 0, x_56); +lean_ctor_set(x_59, 1, x_57); +return x_59; +} +} +} +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; +x_60 = lean_ctor_get(x_5, 1); +lean_inc(x_60); +lean_dec(x_5); +x_61 = lean_ctor_get(x_6, 1); +lean_inc(x_61); +lean_dec(x_6); +x_62 = lean_ctor_get(x_7, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_7, 1); +lean_inc(x_63); +if (lean_is_exclusive(x_7)) { + lean_ctor_release(x_7, 0); + lean_ctor_release(x_7, 1); + x_64 = x_7; +} else { + lean_dec_ref(x_7); + x_64 = lean_box(0); +} +x_65 = lean_array_get_size(x_63); +x_66 = lean_unsigned_to_nat(0u); +x_67 = lean_nat_dec_lt(x_66, x_65); +lean_dec(x_65); +if (x_67 == 0) +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_dec(x_63); +lean_dec(x_62); +lean_dec(x_2); +x_68 = lean_box(0); +if (lean_is_scalar(x_64)) { + x_69 = lean_alloc_ctor(0, 2, 0); +} else { + x_69 = x_64; +} +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_61); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_60); +return x_70; +} +else +{ +lean_object* x_71; +lean_dec(x_64); +lean_inc(x_2); +x_71 = l_Lake_Monitor_renderProgress(x_62, x_63, lean_box(0), x_2, x_61, x_60); +lean_dec(x_62); +if (lean_obj_tag(x_71) == 0) +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +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 = lean_ctor_get(x_72, 1); +lean_inc(x_74); +lean_dec(x_72); +lean_inc(x_2); +x_75 = l_Lake_Monitor_sleep(x_2, x_74, x_73); +if (lean_obj_tag(x_75) == 0) +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_75, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_75, 1); +lean_inc(x_77); +lean_dec(x_75); +x_78 = lean_ctor_get(x_76, 1); +lean_inc(x_78); +lean_dec(x_76); +x_1 = x_63; +x_3 = x_78; +x_4 = x_77; +goto _start; +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_dec(x_63); +lean_dec(x_2); +x_80 = lean_ctor_get(x_75, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_75, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + lean_ctor_release(x_75, 1); + x_82 = x_75; +} else { + lean_dec_ref(x_75); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_82)) { + x_83 = lean_alloc_ctor(1, 2, 0); +} else { + x_83 = x_82; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_81); +return x_83; +} +} +else +{ +lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_63); +lean_dec(x_2); +x_84 = lean_ctor_get(x_71, 0); +lean_inc(x_84); +x_85 = lean_ctor_get(x_71, 1); +lean_inc(x_85); +if (lean_is_exclusive(x_71)) { + lean_ctor_release(x_71, 0); + lean_ctor_release(x_71, 1); + x_86 = x_71; +} else { + lean_dec_ref(x_71); + x_86 = lean_box(0); +} +if (lean_is_scalar(x_86)) { + x_87 = lean_alloc_ctor(1, 2, 0); +} else { + x_87 = x_86; +} +lean_ctor_set(x_87, 0, x_84); +lean_ctor_set(x_87, 1, x_85); +return x_87; +} +} +} +} +else +{ +uint8_t x_88; +lean_dec(x_2); +x_88 = !lean_is_exclusive(x_5); +if (x_88 == 0) +{ +return x_5; +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_89 = lean_ctor_get(x_5, 0); +x_90 = lean_ctor_get(x_5, 1); +lean_inc(x_90); +lean_inc(x_89); +lean_dec(x_5); +x_91 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set(x_91, 1, x_90); +return x_91; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Monitor_main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +lean_inc(x_2); +x_5 = l_Lake_Monitor_loop(x_1, x_2, x_3, x_4); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; uint8_t x_7; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = !lean_is_exclusive(x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_8 = lean_ctor_get(x_6, 1); +x_9 = lean_ctor_get(x_6, 0); +lean_dec(x_9); +x_10 = !lean_is_exclusive(x_5); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_11 = lean_ctor_get(x_5, 1); +x_12 = lean_ctor_get(x_5, 0); +lean_dec(x_12); +x_13 = !lean_is_exclusive(x_8); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_14 = lean_ctor_get(x_8, 2); +x_15 = l_Lake_print_x21___closed__10; +lean_ctor_set(x_8, 2, x_15); +x_16 = l_String_isEmpty(x_14); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +lean_free_object(x_5); +x_17 = lean_ctor_get(x_2, 1); +lean_inc(x_17); +lean_dec(x_2); +x_18 = lean_ctor_get(x_17, 4); +lean_inc(x_18); +lean_inc(x_14); +x_19 = lean_apply_2(x_18, x_14, x_11); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +lean_dec(x_14); +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +lean_dec(x_19); +x_21 = lean_ctor_get(x_17, 0); +lean_inc(x_21); +lean_dec(x_17); +x_22 = lean_apply_1(x_21, x_20); +if (lean_obj_tag(x_22) == 0) +{ +uint8_t x_23; +x_23 = !lean_is_exclusive(x_22); +if (x_23 == 0) +{ +lean_object* x_24; +x_24 = lean_ctor_get(x_22, 0); +lean_ctor_set(x_6, 0, x_24); +lean_ctor_set(x_22, 0, x_6); +return x_22; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_22, 0); +x_26 = lean_ctor_get(x_22, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_22); +lean_ctor_set(x_6, 0, x_25); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_6); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +else +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_22); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; +x_29 = lean_ctor_get(x_22, 0); +lean_dec(x_29); +x_30 = lean_box(0); +lean_ctor_set(x_6, 0, x_30); +lean_ctor_set_tag(x_22, 0); +lean_ctor_set(x_22, 0, x_6); +return x_22; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_22, 1); +lean_inc(x_31); +lean_dec(x_22); +x_32 = lean_box(0); +lean_ctor_set(x_6, 0, x_32); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_6); +lean_ctor_set(x_33, 1, x_31); +return x_33; +} +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_34 = lean_ctor_get(x_19, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_19, 1); +lean_inc(x_35); +lean_dec(x_19); +x_36 = lean_io_error_to_string(x_34); +x_37 = l_Lake_print_x21___closed__8; +x_38 = lean_string_append(x_37, x_36); +lean_dec(x_36); +x_39 = l_Lake_print_x21___closed__9; +x_40 = lean_string_append(x_38, x_39); +x_41 = l_String_quote(x_14); +lean_dec(x_14); +x_42 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_42, 0, x_41); +x_43 = l_Std_Format_defWidth; +x_44 = lean_unsigned_to_nat(0u); +x_45 = lean_format_pretty(x_42, x_43, x_44, x_44); +x_46 = lean_string_append(x_40, x_45); +lean_dec(x_45); +x_47 = lean_string_append(x_46, x_15); +x_48 = l_Lake_print_x21___closed__11; +x_49 = l_Lake_print_x21___closed__12; +x_50 = lean_unsigned_to_nat(74u); +x_51 = lean_unsigned_to_nat(4u); +x_52 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_48, x_49, x_50, x_51, x_47); +lean_dec(x_47); +x_53 = l_panic___at_Lake_print_x21___spec__1(x_52, x_35); +if (lean_obj_tag(x_53) == 0) +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = lean_ctor_get(x_17, 0); +lean_inc(x_55); +lean_dec(x_17); +x_56 = lean_apply_1(x_55, x_54); +if (lean_obj_tag(x_56) == 0) +{ +uint8_t x_57; +x_57 = !lean_is_exclusive(x_56); +if (x_57 == 0) +{ +lean_object* x_58; +x_58 = lean_ctor_get(x_56, 0); +lean_ctor_set(x_6, 0, x_58); +lean_ctor_set(x_56, 0, x_6); +return x_56; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_56, 0); +x_60 = lean_ctor_get(x_56, 1); +lean_inc(x_60); +lean_inc(x_59); +lean_dec(x_56); +lean_ctor_set(x_6, 0, x_59); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_6); +lean_ctor_set(x_61, 1, x_60); +return x_61; +} +} +else +{ +uint8_t x_62; +x_62 = !lean_is_exclusive(x_56); +if (x_62 == 0) +{ +lean_object* x_63; lean_object* x_64; +x_63 = lean_ctor_get(x_56, 0); +lean_dec(x_63); +x_64 = lean_box(0); +lean_ctor_set(x_6, 0, x_64); +lean_ctor_set_tag(x_56, 0); +lean_ctor_set(x_56, 0, x_6); +return x_56; +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_ctor_get(x_56, 1); +lean_inc(x_65); +lean_dec(x_56); +x_66 = lean_box(0); +lean_ctor_set(x_6, 0, x_66); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_6); +lean_ctor_set(x_67, 1, x_65); +return x_67; +} +} +} +else +{ +uint8_t x_68; +lean_dec(x_17); +lean_dec(x_8); +lean_free_object(x_6); +x_68 = !lean_is_exclusive(x_53); +if (x_68 == 0) +{ +return x_53; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_53, 0); +x_70 = lean_ctor_get(x_53, 1); +lean_inc(x_70); +lean_inc(x_69); +lean_dec(x_53); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_69); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +} +} +} +else +{ +lean_object* x_72; +lean_dec(x_14); +lean_dec(x_2); +x_72 = lean_box(0); +lean_ctor_set(x_6, 0, x_72); +return x_5; +} +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_73 = lean_ctor_get(x_8, 0); +x_74 = lean_ctor_get(x_8, 1); +x_75 = lean_ctor_get(x_8, 2); +x_76 = lean_ctor_get(x_8, 3); +x_77 = lean_ctor_get(x_8, 4); +lean_inc(x_77); +lean_inc(x_76); +lean_inc(x_75); +lean_inc(x_74); +lean_inc(x_73); +lean_dec(x_8); +x_78 = l_Lake_print_x21___closed__10; +x_79 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_79, 0, x_73); +lean_ctor_set(x_79, 1, x_74); +lean_ctor_set(x_79, 2, x_78); +lean_ctor_set(x_79, 3, x_76); +lean_ctor_set(x_79, 4, x_77); +x_80 = l_String_isEmpty(x_75); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_free_object(x_5); +x_81 = lean_ctor_get(x_2, 1); +lean_inc(x_81); +lean_dec(x_2); +x_82 = lean_ctor_get(x_81, 4); +lean_inc(x_82); +lean_inc(x_75); +x_83 = lean_apply_2(x_82, x_75, x_11); +if (lean_obj_tag(x_83) == 0) +{ +lean_object* x_84; lean_object* x_85; lean_object* x_86; +lean_dec(x_75); +x_84 = lean_ctor_get(x_83, 1); +lean_inc(x_84); +lean_dec(x_83); +x_85 = lean_ctor_get(x_81, 0); +lean_inc(x_85); +lean_dec(x_81); +x_86 = lean_apply_1(x_85, x_84); +if (lean_obj_tag(x_86) == 0) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_87 = lean_ctor_get(x_86, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_86, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_86)) { + lean_ctor_release(x_86, 0); + lean_ctor_release(x_86, 1); + x_89 = x_86; +} else { + lean_dec_ref(x_86); + x_89 = lean_box(0); +} +lean_ctor_set(x_6, 1, x_79); +lean_ctor_set(x_6, 0, x_87); +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(0, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_6); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_91 = lean_ctor_get(x_86, 1); +lean_inc(x_91); +if (lean_is_exclusive(x_86)) { + lean_ctor_release(x_86, 0); + lean_ctor_release(x_86, 1); + x_92 = x_86; +} else { + lean_dec_ref(x_86); + x_92 = lean_box(0); +} +x_93 = lean_box(0); +lean_ctor_set(x_6, 1, x_79); +lean_ctor_set(x_6, 0, x_93); +if (lean_is_scalar(x_92)) { + x_94 = lean_alloc_ctor(0, 2, 0); +} else { + x_94 = x_92; + lean_ctor_set_tag(x_94, 0); +} +lean_ctor_set(x_94, 0, x_6); +lean_ctor_set(x_94, 1, x_91); +return x_94; +} +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; +x_95 = lean_ctor_get(x_83, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_83, 1); +lean_inc(x_96); +lean_dec(x_83); +x_97 = lean_io_error_to_string(x_95); +x_98 = l_Lake_print_x21___closed__8; +x_99 = lean_string_append(x_98, x_97); +lean_dec(x_97); +x_100 = l_Lake_print_x21___closed__9; +x_101 = lean_string_append(x_99, x_100); +x_102 = l_String_quote(x_75); +lean_dec(x_75); +x_103 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_103, 0, x_102); +x_104 = l_Std_Format_defWidth; +x_105 = lean_unsigned_to_nat(0u); +x_106 = lean_format_pretty(x_103, x_104, x_105, x_105); +x_107 = lean_string_append(x_101, x_106); +lean_dec(x_106); +x_108 = lean_string_append(x_107, x_78); +x_109 = l_Lake_print_x21___closed__11; +x_110 = l_Lake_print_x21___closed__12; +x_111 = lean_unsigned_to_nat(74u); +x_112 = lean_unsigned_to_nat(4u); +x_113 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_109, x_110, x_111, x_112, x_108); +lean_dec(x_108); +x_114 = l_panic___at_Lake_print_x21___spec__1(x_113, x_96); +if (lean_obj_tag(x_114) == 0) +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_115 = lean_ctor_get(x_114, 1); +lean_inc(x_115); +lean_dec(x_114); +x_116 = lean_ctor_get(x_81, 0); +lean_inc(x_116); +lean_dec(x_81); +x_117 = lean_apply_1(x_116, x_115); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; +x_118 = lean_ctor_get(x_117, 0); +lean_inc(x_118); +x_119 = lean_ctor_get(x_117, 1); +lean_inc(x_119); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_120 = x_117; +} else { + lean_dec_ref(x_117); + x_120 = lean_box(0); +} +lean_ctor_set(x_6, 1, x_79); +lean_ctor_set(x_6, 0, x_118); +if (lean_is_scalar(x_120)) { + x_121 = lean_alloc_ctor(0, 2, 0); +} else { + x_121 = x_120; +} +lean_ctor_set(x_121, 0, x_6); +lean_ctor_set(x_121, 1, x_119); +return x_121; +} +else +{ +lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +x_124 = lean_box(0); +lean_ctor_set(x_6, 1, x_79); +lean_ctor_set(x_6, 0, x_124); +if (lean_is_scalar(x_123)) { + x_125 = lean_alloc_ctor(0, 2, 0); +} else { + x_125 = x_123; + lean_ctor_set_tag(x_125, 0); +} +lean_ctor_set(x_125, 0, x_6); +lean_ctor_set(x_125, 1, x_122); +return x_125; +} +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; +lean_dec(x_81); +lean_dec(x_79); +lean_free_object(x_6); +x_126 = lean_ctor_get(x_114, 0); +lean_inc(x_126); +x_127 = lean_ctor_get(x_114, 1); +lean_inc(x_127); +if (lean_is_exclusive(x_114)) { + lean_ctor_release(x_114, 0); + lean_ctor_release(x_114, 1); + x_128 = x_114; +} else { + lean_dec_ref(x_114); + x_128 = lean_box(0); +} +if (lean_is_scalar(x_128)) { + x_129 = lean_alloc_ctor(1, 2, 0); +} else { + x_129 = x_128; +} +lean_ctor_set(x_129, 0, x_126); +lean_ctor_set(x_129, 1, x_127); +return x_129; +} +} +} +else +{ +lean_object* x_130; +lean_dec(x_75); +lean_dec(x_2); +x_130 = lean_box(0); +lean_ctor_set(x_6, 1, x_79); +lean_ctor_set(x_6, 0, x_130); +return x_5; +} +} +} +else +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; uint8_t x_140; +x_131 = lean_ctor_get(x_5, 1); +lean_inc(x_131); +lean_dec(x_5); +x_132 = lean_ctor_get(x_8, 0); +lean_inc(x_132); +x_133 = lean_ctor_get(x_8, 1); +lean_inc(x_133); +x_134 = lean_ctor_get(x_8, 2); +lean_inc(x_134); +x_135 = lean_ctor_get(x_8, 3); +lean_inc(x_135); +x_136 = lean_ctor_get(x_8, 4); +lean_inc(x_136); +if (lean_is_exclusive(x_8)) { + lean_ctor_release(x_8, 0); + lean_ctor_release(x_8, 1); + lean_ctor_release(x_8, 2); + lean_ctor_release(x_8, 3); + lean_ctor_release(x_8, 4); + x_137 = x_8; +} else { + lean_dec_ref(x_8); + x_137 = lean_box(0); +} +x_138 = l_Lake_print_x21___closed__10; +if (lean_is_scalar(x_137)) { + x_139 = lean_alloc_ctor(0, 5, 0); +} else { + x_139 = x_137; +} +lean_ctor_set(x_139, 0, x_132); +lean_ctor_set(x_139, 1, x_133); +lean_ctor_set(x_139, 2, x_138); +lean_ctor_set(x_139, 3, x_135); +lean_ctor_set(x_139, 4, x_136); +x_140 = l_String_isEmpty(x_134); +if (x_140 == 0) +{ +lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_141 = lean_ctor_get(x_2, 1); +lean_inc(x_141); +lean_dec(x_2); +x_142 = lean_ctor_get(x_141, 4); +lean_inc(x_142); +lean_inc(x_134); +x_143 = lean_apply_2(x_142, x_134, x_131); +if (lean_obj_tag(x_143) == 0) +{ +lean_object* x_144; lean_object* x_145; lean_object* x_146; +lean_dec(x_134); +x_144 = lean_ctor_get(x_143, 1); +lean_inc(x_144); +lean_dec(x_143); +x_145 = lean_ctor_get(x_141, 0); +lean_inc(x_145); +lean_dec(x_141); +x_146 = lean_apply_1(x_145, x_144); +if (lean_obj_tag(x_146) == 0) +{ +lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_147 = lean_ctor_get(x_146, 0); +lean_inc(x_147); +x_148 = lean_ctor_get(x_146, 1); +lean_inc(x_148); +if (lean_is_exclusive(x_146)) { + lean_ctor_release(x_146, 0); + lean_ctor_release(x_146, 1); + x_149 = x_146; +} else { + lean_dec_ref(x_146); + x_149 = lean_box(0); +} +lean_ctor_set(x_6, 1, x_139); +lean_ctor_set(x_6, 0, x_147); +if (lean_is_scalar(x_149)) { + x_150 = lean_alloc_ctor(0, 2, 0); +} else { + x_150 = x_149; +} +lean_ctor_set(x_150, 0, x_6); +lean_ctor_set(x_150, 1, x_148); +return x_150; +} +else +{ +lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_151 = lean_ctor_get(x_146, 1); +lean_inc(x_151); +if (lean_is_exclusive(x_146)) { + lean_ctor_release(x_146, 0); + lean_ctor_release(x_146, 1); + x_152 = x_146; +} else { + lean_dec_ref(x_146); + x_152 = lean_box(0); +} +x_153 = lean_box(0); +lean_ctor_set(x_6, 1, x_139); +lean_ctor_set(x_6, 0, x_153); +if (lean_is_scalar(x_152)) { + x_154 = lean_alloc_ctor(0, 2, 0); +} else { + x_154 = x_152; + lean_ctor_set_tag(x_154, 0); +} +lean_ctor_set(x_154, 0, x_6); +lean_ctor_set(x_154, 1, x_151); +return x_154; +} +} +else +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; +x_155 = lean_ctor_get(x_143, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_143, 1); +lean_inc(x_156); +lean_dec(x_143); +x_157 = lean_io_error_to_string(x_155); +x_158 = l_Lake_print_x21___closed__8; +x_159 = lean_string_append(x_158, x_157); +lean_dec(x_157); +x_160 = l_Lake_print_x21___closed__9; +x_161 = lean_string_append(x_159, x_160); +x_162 = l_String_quote(x_134); +lean_dec(x_134); +x_163 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_163, 0, x_162); +x_164 = l_Std_Format_defWidth; +x_165 = lean_unsigned_to_nat(0u); +x_166 = lean_format_pretty(x_163, x_164, x_165, x_165); +x_167 = lean_string_append(x_161, x_166); +lean_dec(x_166); +x_168 = lean_string_append(x_167, x_138); +x_169 = l_Lake_print_x21___closed__11; +x_170 = l_Lake_print_x21___closed__12; +x_171 = lean_unsigned_to_nat(74u); +x_172 = lean_unsigned_to_nat(4u); +x_173 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_169, x_170, x_171, x_172, x_168); +lean_dec(x_168); +x_174 = l_panic___at_Lake_print_x21___spec__1(x_173, x_156); +if (lean_obj_tag(x_174) == 0) +{ +lean_object* x_175; lean_object* x_176; lean_object* x_177; +x_175 = lean_ctor_get(x_174, 1); +lean_inc(x_175); +lean_dec(x_174); +x_176 = lean_ctor_get(x_141, 0); +lean_inc(x_176); +lean_dec(x_141); +x_177 = lean_apply_1(x_176, x_175); +if (lean_obj_tag(x_177) == 0) +{ +lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_178 = lean_ctor_get(x_177, 0); +lean_inc(x_178); +x_179 = lean_ctor_get(x_177, 1); +lean_inc(x_179); +if (lean_is_exclusive(x_177)) { + lean_ctor_release(x_177, 0); + lean_ctor_release(x_177, 1); + x_180 = x_177; +} else { + lean_dec_ref(x_177); + x_180 = lean_box(0); +} +lean_ctor_set(x_6, 1, x_139); +lean_ctor_set(x_6, 0, x_178); +if (lean_is_scalar(x_180)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_180; +} +lean_ctor_set(x_181, 0, x_6); +lean_ctor_set(x_181, 1, x_179); +return x_181; +} +else +{ +lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; +x_182 = lean_ctor_get(x_177, 1); +lean_inc(x_182); +if (lean_is_exclusive(x_177)) { + lean_ctor_release(x_177, 0); + lean_ctor_release(x_177, 1); + x_183 = x_177; +} else { + lean_dec_ref(x_177); + x_183 = lean_box(0); +} +x_184 = lean_box(0); +lean_ctor_set(x_6, 1, x_139); +lean_ctor_set(x_6, 0, x_184); +if (lean_is_scalar(x_183)) { + x_185 = lean_alloc_ctor(0, 2, 0); +} else { + x_185 = x_183; + lean_ctor_set_tag(x_185, 0); +} +lean_ctor_set(x_185, 0, x_6); +lean_ctor_set(x_185, 1, x_182); +return x_185; +} +} +else +{ +lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; +lean_dec(x_141); +lean_dec(x_139); +lean_free_object(x_6); +x_186 = lean_ctor_get(x_174, 0); +lean_inc(x_186); +x_187 = lean_ctor_get(x_174, 1); +lean_inc(x_187); +if (lean_is_exclusive(x_174)) { + lean_ctor_release(x_174, 0); + lean_ctor_release(x_174, 1); + x_188 = x_174; +} else { + lean_dec_ref(x_174); + x_188 = lean_box(0); +} +if (lean_is_scalar(x_188)) { + x_189 = lean_alloc_ctor(1, 2, 0); +} else { + x_189 = x_188; +} +lean_ctor_set(x_189, 0, x_186); +lean_ctor_set(x_189, 1, x_187); +return x_189; +} +} +} +else +{ +lean_object* x_190; lean_object* x_191; +lean_dec(x_134); +lean_dec(x_2); +x_190 = lean_box(0); +lean_ctor_set(x_6, 1, x_139); +lean_ctor_set(x_6, 0, x_190); +x_191 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_191, 0, x_6); +lean_ctor_set(x_191, 1, x_131); +return x_191; +} +} +} +else +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; uint8_t x_203; +x_192 = lean_ctor_get(x_6, 1); +lean_inc(x_192); +lean_dec(x_6); +x_193 = lean_ctor_get(x_5, 1); +lean_inc(x_193); +if (lean_is_exclusive(x_5)) { + lean_ctor_release(x_5, 0); + lean_ctor_release(x_5, 1); + x_194 = x_5; +} else { + lean_dec_ref(x_5); + x_194 = lean_box(0); +} +x_195 = lean_ctor_get(x_192, 0); +lean_inc(x_195); +x_196 = lean_ctor_get(x_192, 1); +lean_inc(x_196); +x_197 = lean_ctor_get(x_192, 2); +lean_inc(x_197); +x_198 = lean_ctor_get(x_192, 3); +lean_inc(x_198); +x_199 = lean_ctor_get(x_192, 4); +lean_inc(x_199); +if (lean_is_exclusive(x_192)) { + lean_ctor_release(x_192, 0); + lean_ctor_release(x_192, 1); + lean_ctor_release(x_192, 2); + lean_ctor_release(x_192, 3); + lean_ctor_release(x_192, 4); + x_200 = x_192; +} else { + lean_dec_ref(x_192); + x_200 = lean_box(0); +} +x_201 = l_Lake_print_x21___closed__10; +if (lean_is_scalar(x_200)) { + x_202 = lean_alloc_ctor(0, 5, 0); +} else { + x_202 = x_200; +} +lean_ctor_set(x_202, 0, x_195); +lean_ctor_set(x_202, 1, x_196); +lean_ctor_set(x_202, 2, x_201); +lean_ctor_set(x_202, 3, x_198); +lean_ctor_set(x_202, 4, x_199); +x_203 = l_String_isEmpty(x_197); +if (x_203 == 0) +{ +lean_object* x_204; lean_object* x_205; lean_object* x_206; +lean_dec(x_194); +x_204 = lean_ctor_get(x_2, 1); +lean_inc(x_204); +lean_dec(x_2); +x_205 = lean_ctor_get(x_204, 4); +lean_inc(x_205); +lean_inc(x_197); +x_206 = lean_apply_2(x_205, x_197, x_193); +if (lean_obj_tag(x_206) == 0) +{ +lean_object* x_207; lean_object* x_208; lean_object* x_209; +lean_dec(x_197); +x_207 = lean_ctor_get(x_206, 1); +lean_inc(x_207); +lean_dec(x_206); +x_208 = lean_ctor_get(x_204, 0); +lean_inc(x_208); +lean_dec(x_204); +x_209 = lean_apply_1(x_208, x_207); +if (lean_obj_tag(x_209) == 0) +{ +lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; +x_210 = lean_ctor_get(x_209, 0); +lean_inc(x_210); +x_211 = lean_ctor_get(x_209, 1); +lean_inc(x_211); +if (lean_is_exclusive(x_209)) { + lean_ctor_release(x_209, 0); + lean_ctor_release(x_209, 1); + x_212 = x_209; +} else { + lean_dec_ref(x_209); + x_212 = lean_box(0); +} +x_213 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_213, 0, x_210); +lean_ctor_set(x_213, 1, x_202); +if (lean_is_scalar(x_212)) { + x_214 = lean_alloc_ctor(0, 2, 0); +} else { + x_214 = x_212; +} +lean_ctor_set(x_214, 0, x_213); +lean_ctor_set(x_214, 1, x_211); +return x_214; +} +else +{ +lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; +x_215 = lean_ctor_get(x_209, 1); +lean_inc(x_215); +if (lean_is_exclusive(x_209)) { + lean_ctor_release(x_209, 0); + lean_ctor_release(x_209, 1); + x_216 = x_209; +} else { + lean_dec_ref(x_209); + x_216 = lean_box(0); +} +x_217 = lean_box(0); +x_218 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_218, 0, x_217); +lean_ctor_set(x_218, 1, x_202); +if (lean_is_scalar(x_216)) { + x_219 = lean_alloc_ctor(0, 2, 0); +} else { + x_219 = x_216; + lean_ctor_set_tag(x_219, 0); +} +lean_ctor_set(x_219, 0, x_218); +lean_ctor_set(x_219, 1, x_215); +return x_219; +} +} +else +{ +lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; +x_220 = lean_ctor_get(x_206, 0); +lean_inc(x_220); +x_221 = lean_ctor_get(x_206, 1); +lean_inc(x_221); +lean_dec(x_206); +x_222 = lean_io_error_to_string(x_220); +x_223 = l_Lake_print_x21___closed__8; +x_224 = lean_string_append(x_223, x_222); +lean_dec(x_222); +x_225 = l_Lake_print_x21___closed__9; +x_226 = lean_string_append(x_224, x_225); +x_227 = l_String_quote(x_197); +lean_dec(x_197); +x_228 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_228, 0, x_227); +x_229 = l_Std_Format_defWidth; +x_230 = lean_unsigned_to_nat(0u); +x_231 = lean_format_pretty(x_228, x_229, x_230, x_230); +x_232 = lean_string_append(x_226, x_231); +lean_dec(x_231); +x_233 = lean_string_append(x_232, x_201); +x_234 = l_Lake_print_x21___closed__11; +x_235 = l_Lake_print_x21___closed__12; +x_236 = lean_unsigned_to_nat(74u); +x_237 = lean_unsigned_to_nat(4u); +x_238 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_234, x_235, x_236, x_237, x_233); +lean_dec(x_233); +x_239 = l_panic___at_Lake_print_x21___spec__1(x_238, x_221); +if (lean_obj_tag(x_239) == 0) +{ +lean_object* x_240; lean_object* x_241; lean_object* x_242; +x_240 = lean_ctor_get(x_239, 1); +lean_inc(x_240); +lean_dec(x_239); +x_241 = lean_ctor_get(x_204, 0); +lean_inc(x_241); +lean_dec(x_204); +x_242 = lean_apply_1(x_241, x_240); +if (lean_obj_tag(x_242) == 0) +{ +lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; +x_243 = lean_ctor_get(x_242, 0); +lean_inc(x_243); +x_244 = lean_ctor_get(x_242, 1); +lean_inc(x_244); +if (lean_is_exclusive(x_242)) { + lean_ctor_release(x_242, 0); + lean_ctor_release(x_242, 1); + x_245 = x_242; +} else { + lean_dec_ref(x_242); + x_245 = lean_box(0); +} +x_246 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_246, 0, x_243); +lean_ctor_set(x_246, 1, x_202); +if (lean_is_scalar(x_245)) { + x_247 = lean_alloc_ctor(0, 2, 0); +} else { + x_247 = x_245; +} +lean_ctor_set(x_247, 0, x_246); +lean_ctor_set(x_247, 1, x_244); +return x_247; +} +else +{ +lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; +x_248 = lean_ctor_get(x_242, 1); +lean_inc(x_248); +if (lean_is_exclusive(x_242)) { + lean_ctor_release(x_242, 0); + lean_ctor_release(x_242, 1); + x_249 = x_242; +} else { + lean_dec_ref(x_242); + x_249 = lean_box(0); +} +x_250 = lean_box(0); +x_251 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_202); +if (lean_is_scalar(x_249)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_249; + lean_ctor_set_tag(x_252, 0); +} +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_248); +return x_252; +} +} +else +{ +lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; +lean_dec(x_204); +lean_dec(x_202); +x_253 = lean_ctor_get(x_239, 0); +lean_inc(x_253); +x_254 = lean_ctor_get(x_239, 1); +lean_inc(x_254); +if (lean_is_exclusive(x_239)) { + lean_ctor_release(x_239, 0); + lean_ctor_release(x_239, 1); + x_255 = x_239; +} else { + lean_dec_ref(x_239); + x_255 = lean_box(0); +} +if (lean_is_scalar(x_255)) { + x_256 = lean_alloc_ctor(1, 2, 0); +} else { + x_256 = x_255; +} +lean_ctor_set(x_256, 0, x_253); +lean_ctor_set(x_256, 1, x_254); +return x_256; +} +} +} +else +{ +lean_object* x_257; lean_object* x_258; lean_object* x_259; +lean_dec(x_197); +lean_dec(x_2); +x_257 = lean_box(0); +x_258 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_258, 0, x_257); +lean_ctor_set(x_258, 1, x_202); +if (lean_is_scalar(x_194)) { + x_259 = lean_alloc_ctor(0, 2, 0); +} else { + x_259 = x_194; +} +lean_ctor_set(x_259, 0, x_258); +lean_ctor_set(x_259, 1, x_193); +return x_259; +} +} +} +else +{ +uint8_t x_260; +lean_dec(x_2); +x_260 = !lean_is_exclusive(x_5); +if (x_260 == 0) +{ +return x_5; +} +else +{ +lean_object* x_261; lean_object* x_262; lean_object* x_263; +x_261 = lean_ctor_get(x_5, 0); +x_262 = lean_ctor_get(x_5, 1); +lean_inc(x_262); +lean_inc(x_261); +lean_dec(x_5); +x_263 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_263, 0, x_261); +lean_ctor_set(x_263, 1, x_262); +return x_263; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_monitorJobs(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, uint8_t x_5, uint8_t x_6, uint8_t x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_alloc_ctor(0, 3, 5); +lean_ctor_set(x_13, 0, x_10); +lean_ctor_set(x_13, 1, x_2); +lean_ctor_set(x_13, 2, x_11); +lean_ctor_set_uint8(x_13, sizeof(void*)*3, x_4); +lean_ctor_set_uint8(x_13, sizeof(void*)*3 + 1, x_3); +lean_ctor_set_uint8(x_13, sizeof(void*)*3 + 2, x_5); +lean_ctor_set_uint8(x_13, sizeof(void*)*3 + 3, x_6); +lean_ctor_set_uint8(x_13, sizeof(void*)*3 + 4, x_7); +x_14 = lean_io_mono_ms_now(x_12); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +lean_dec(x_14); +x_17 = lean_unsigned_to_nat(1u); +x_18 = lean_unsigned_to_nat(0u); +x_19 = lean_alloc_ctor(0, 5, 0); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set(x_19, 1, x_9); +lean_ctor_set(x_19, 2, x_8); +lean_ctor_set(x_19, 3, x_15); +lean_ctor_set(x_19, 4, x_18); +x_20 = l_Lake_Monitor_main(x_1, x_13, x_19, x_16); +if (lean_obj_tag(x_20) == 0) +{ +uint8_t x_21; +x_21 = !lean_is_exclusive(x_20); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_20, 0); +x_23 = lean_ctor_get(x_22, 1); +lean_inc(x_23); +lean_dec(x_22); +x_24 = lean_ctor_get(x_23, 1); +lean_inc(x_24); +lean_dec(x_23); +lean_ctor_set(x_20, 0, x_24); +return x_20; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_20, 0); +x_26 = lean_ctor_get(x_20, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_20); +x_27 = lean_ctor_get(x_25, 1); +lean_inc(x_27); +lean_dec(x_25); +x_28 = lean_ctor_get(x_27, 1); +lean_inc(x_28); +lean_dec(x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +return x_29; +} +} +else +{ +uint8_t x_30; +x_30 = !lean_is_exclusive(x_20); +if (x_30 == 0) +{ +return x_20; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_20, 0); +x_32 = lean_ctor_get(x_20, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_20); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +return x_33; +} +} +} +else +{ +uint8_t x_34; +lean_dec(x_13); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_1); +x_34 = !lean_is_exclusive(x_14); +if (x_34 == 0) +{ +return x_14; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_ctor_get(x_14, 0); +x_36 = lean_ctor_get(x_14, 1); +lean_inc(x_36); +lean_inc(x_35); +lean_dec(x_14); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +return x_37; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_monitorJobs___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +uint8_t x_13; uint8_t x_14; uint8_t x_15; uint8_t x_16; uint8_t x_17; lean_object* x_18; +x_13 = lean_unbox(x_3); +lean_dec(x_3); +x_14 = lean_unbox(x_4); +lean_dec(x_4); +x_15 = lean_unbox(x_5); +lean_dec(x_5); +x_16 = lean_unbox(x_6); +lean_dec(x_6); +x_17 = lean_unbox(x_7); +lean_dec(x_7); +x_18 = l_Lake_monitorJobs(x_1, x_2, x_13, x_14, x_15, x_16, x_17, x_8, x_9, x_10, x_11, x_12); +return x_18; +} +} +static lean_object* _init_l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("- ", 2); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = lean_usize_dec_eq(x_3, x_4); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_5); +x_8 = lean_array_uget(x_2, x_3); +x_9 = l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___closed__1; +x_10 = lean_string_append(x_9, x_8); +lean_dec(x_8); +x_11 = l_Lake_Monitor_reportJob___lambda__2___closed__2; +x_12 = lean_string_append(x_10, x_11); +x_13 = lean_ctor_get(x_1, 4); +lean_inc(x_13); +lean_inc(x_12); +x_14 = lean_apply_2(x_13, x_12, x_6); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; size_t x_17; size_t x_18; +lean_dec(x_12); +x_15 = lean_ctor_get(x_14, 0); +lean_inc(x_15); +x_16 = lean_ctor_get(x_14, 1); +lean_inc(x_16); +lean_dec(x_14); +x_17 = 1; +x_18 = lean_usize_add(x_3, x_17); +x_3 = x_18; +x_5 = x_15; +x_6 = x_16; +goto _start; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; size_t x_43; size_t x_44; +x_20 = lean_ctor_get(x_14, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_14, 1); +lean_inc(x_21); +lean_dec(x_14); +x_22 = lean_io_error_to_string(x_20); +x_23 = l_Lake_print_x21___closed__8; +x_24 = lean_string_append(x_23, x_22); +lean_dec(x_22); +x_25 = l_Lake_print_x21___closed__9; +x_26 = lean_string_append(x_24, x_25); +x_27 = l_String_quote(x_12); +lean_dec(x_12); +x_28 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_28, 0, x_27); +x_29 = l_Std_Format_defWidth; +x_30 = lean_unsigned_to_nat(0u); +x_31 = lean_format_pretty(x_28, x_29, x_30, x_30); +x_32 = lean_string_append(x_26, x_31); +lean_dec(x_31); +x_33 = l_Lake_print_x21___closed__10; +x_34 = lean_string_append(x_32, x_33); +x_35 = l_Lake_print_x21___closed__11; +x_36 = l_Lake_print_x21___closed__12; +x_37 = lean_unsigned_to_nat(74u); +x_38 = lean_unsigned_to_nat(4u); +x_39 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_35, x_36, x_37, x_38, x_34); +lean_dec(x_34); +x_40 = l_panic___at_Lake_print_x21___spec__1(x_39, x_21); +x_41 = lean_ctor_get(x_40, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_40, 1); +lean_inc(x_42); +lean_dec(x_40); +x_43 = 1; +x_44 = lean_usize_add(x_3, x_43); +x_3 = x_44; +x_5 = x_41; +x_6 = x_42; +goto _start; +} +} +else +{ +lean_object* x_46; +lean_dec(x_1); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_5); +lean_ctor_set(x_46, 1, x_6); +return x_46; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__2(lean_object* x_1, uint8_t x_2, uint8_t x_3, lean_object* x_4, size_t x_5, size_t x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +uint8_t x_9; +x_9 = lean_usize_dec_eq(x_5, x_6); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; size_t x_14; size_t x_15; +lean_dec(x_7); +x_10 = lean_array_uget(x_4, x_5); +lean_inc(x_1); +x_11 = l_Lake_logToStream(x_10, x_1, x_3, x_2, x_8); +lean_dec(x_10); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_11, 1); +lean_inc(x_13); +lean_dec(x_11); +x_14 = 1; +x_15 = lean_usize_add(x_5, x_14); +x_5 = x_15; +x_7 = x_12; +x_8 = x_13; +goto _start; +} +else +{ +lean_object* x_17; +lean_dec(x_1); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_7); +lean_ctor_set(x_17, 1, x_8); +return x_17; +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdout(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__4(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__4___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__5___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdin(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__5(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__5___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Workspace_runFetchM___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stderr(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stderr(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stderr(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stderr(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stderr(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stderr(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stderr(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStderr___at_Lake_Workspace_runFetchM___spec__6(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Workspace_runFetchM___spec__6___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__7___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdout(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdout(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdout(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__7(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__7___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__8___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_45; +x_45 = lean_get_set_stdin(x_1, x_8); +if (lean_obj_tag(x_45) == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +x_48 = lean_apply_6(x_2, x_3, x_4, x_5, x_6, x_7, x_47); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_48, 0); +lean_inc(x_49); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +if (lean_obj_tag(x_50) == 0) +{ +lean_object* x_51; uint8_t x_52; +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = !lean_is_exclusive(x_49); +if (x_52 == 0) +{ +lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_53 = lean_ctor_get(x_49, 1); +x_54 = lean_ctor_get(x_49, 0); +lean_dec(x_54); +x_55 = !lean_is_exclusive(x_50); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_50, 0); +x_57 = lean_ctor_get(x_50, 1); +x_58 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_box(0); +lean_ctor_set(x_49, 1, x_60); +lean_ctor_set(x_49, 0, x_56); +lean_ctor_set(x_50, 0, x_49); +x_61 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_61, 0, x_50); +lean_ctor_set(x_61, 1, x_53); +x_9 = x_61; +x_10 = x_59; +goto block_44; +} +else +{ +uint8_t x_62; +lean_free_object(x_50); +lean_dec(x_57); +lean_dec(x_56); +lean_free_object(x_49); +lean_dec(x_53); +x_62 = !lean_is_exclusive(x_58); +if (x_62 == 0) +{ +return x_58; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_58, 0); +x_64 = lean_ctor_get(x_58, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_58); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_50, 0); +x_67 = lean_ctor_get(x_50, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_50); +x_68 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_68, 1); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_box(0); +lean_ctor_set(x_49, 1, x_70); +lean_ctor_set(x_49, 0, x_66); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_49); +lean_ctor_set(x_71, 1, x_67); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_53); +x_9 = x_72; +x_10 = x_69; +goto block_44; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_49); +lean_dec(x_53); +x_73 = lean_ctor_get(x_68, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(1, 2, 0); +} else { + x_76 = x_75; +} +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; +} +} +} +else +{ +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_77 = lean_ctor_get(x_49, 1); +lean_inc(x_77); +lean_dec(x_49); +x_78 = lean_ctor_get(x_50, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_50, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_80 = x_50; +} else { + lean_dec_ref(x_50); + x_80 = lean_box(0); +} +x_81 = lean_get_set_stdin(x_46, x_51); +if (lean_obj_tag(x_81) == 0) +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_82 = lean_ctor_get(x_81, 1); +lean_inc(x_82); +lean_dec(x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_80)) { + x_85 = lean_alloc_ctor(0, 2, 0); +} else { + x_85 = x_80; +} +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_79); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_77); +x_9 = x_86; +x_10 = x_82; +goto block_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +lean_dec(x_80); +lean_dec(x_79); +lean_dec(x_78); +lean_dec(x_77); +x_87 = lean_ctor_get(x_81, 0); +lean_inc(x_87); +x_88 = lean_ctor_get(x_81, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_81)) { + lean_ctor_release(x_81, 0); + lean_ctor_release(x_81, 1); + x_89 = x_81; +} else { + lean_dec_ref(x_81); + x_89 = lean_box(0); +} +if (lean_is_scalar(x_89)) { + x_90 = lean_alloc_ctor(1, 2, 0); +} else { + x_90 = x_89; +} +lean_ctor_set(x_90, 0, x_87); +lean_ctor_set(x_90, 1, x_88); +return x_90; +} +} +} +else +{ +lean_object* x_91; uint8_t x_92; +x_91 = lean_ctor_get(x_48, 1); +lean_inc(x_91); +lean_dec(x_48); +x_92 = !lean_is_exclusive(x_49); +if (x_92 == 0) +{ +lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_93 = lean_ctor_get(x_49, 1); +x_94 = lean_ctor_get(x_49, 0); +lean_dec(x_94); +x_95 = !lean_is_exclusive(x_50); +if (x_95 == 0) +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_50, 0); +x_97 = lean_ctor_get(x_50, 1); +x_98 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; +x_99 = lean_ctor_get(x_98, 1); +lean_inc(x_99); +lean_dec(x_98); +x_9 = x_49; +x_10 = x_99; +goto block_44; +} +else +{ +uint8_t x_100; +lean_free_object(x_50); +lean_dec(x_97); +lean_dec(x_96); +lean_free_object(x_49); +lean_dec(x_93); +x_100 = !lean_is_exclusive(x_98); +if (x_100 == 0) +{ +return x_98; +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_101 = lean_ctor_get(x_98, 0); +x_102 = lean_ctor_get(x_98, 1); +lean_inc(x_102); +lean_inc(x_101); +lean_dec(x_98); +x_103 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_103, 0, x_101); +lean_ctor_set(x_103, 1, x_102); +return x_103; +} +} +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_50, 0); +x_105 = lean_ctor_get(x_50, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_50); +x_106 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; +x_107 = lean_ctor_get(x_106, 1); +lean_inc(x_107); +lean_dec(x_106); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_104); +lean_ctor_set(x_108, 1, x_105); +lean_ctor_set(x_49, 0, x_108); +x_9 = x_49; +x_10 = x_107; +goto block_44; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +lean_dec(x_105); +lean_dec(x_104); +lean_free_object(x_49); +lean_dec(x_93); +x_109 = lean_ctor_get(x_106, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_106, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_111 = x_106; +} else { + lean_dec_ref(x_106); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +return x_112; +} +} +} +else +{ +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_113 = lean_ctor_get(x_49, 1); +lean_inc(x_113); +lean_dec(x_49); +x_114 = lean_ctor_get(x_50, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_50, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_50)) { + lean_ctor_release(x_50, 0); + lean_ctor_release(x_50, 1); + x_116 = x_50; +} else { + lean_dec_ref(x_50); + x_116 = lean_box(0); +} +x_117 = lean_get_set_stdin(x_46, x_91); +if (lean_obj_tag(x_117) == 0) +{ +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_117, 1); +lean_inc(x_118); +lean_dec(x_117); +if (lean_is_scalar(x_116)) { + x_119 = lean_alloc_ctor(1, 2, 0); +} else { + x_119 = x_116; +} +lean_ctor_set(x_119, 0, x_114); +lean_ctor_set(x_119, 1, x_115); +x_120 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_113); +x_9 = x_120; +x_10 = x_118; +goto block_44; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +lean_dec(x_116); +lean_dec(x_115); +lean_dec(x_114); +lean_dec(x_113); +x_121 = lean_ctor_get(x_117, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_117, 1); +lean_inc(x_122); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_123 = x_117; +} else { + lean_dec_ref(x_117); + x_123 = lean_box(0); +} +if (lean_is_scalar(x_123)) { + x_124 = lean_alloc_ctor(1, 2, 0); +} else { + x_124 = x_123; +} +lean_ctor_set(x_124, 0, x_121); +lean_ctor_set(x_124, 1, x_122); +return x_124; +} +} +} +} +else +{ +uint8_t x_125; +lean_dec(x_46); +x_125 = !lean_is_exclusive(x_48); +if (x_125 == 0) +{ +return x_48; +} +else +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; +x_126 = lean_ctor_get(x_48, 0); +x_127 = lean_ctor_get(x_48, 1); +lean_inc(x_127); +lean_inc(x_126); +lean_dec(x_48); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_126); +lean_ctor_set(x_128, 1, x_127); +return x_128; +} +} +} +else +{ +uint8_t x_129; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_129 = !lean_is_exclusive(x_45); +if (x_129 == 0) +{ +return x_45; +} +else +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_130 = lean_ctor_get(x_45, 0); +x_131 = lean_ctor_get(x_45, 1); +lean_inc(x_131); +lean_inc(x_130); +lean_dec(x_45); +x_132 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_132, 0, x_130); +lean_ctor_set(x_132, 1, x_131); +return x_132; +} +} +block_44: +{ +lean_object* x_11; +x_11 = lean_ctor_get(x_9, 0); +lean_inc(x_11); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; uint8_t x_14; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_9, 1); +lean_inc(x_13); +lean_dec(x_9); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +lean_ctor_set(x_11, 0, x_17); +lean_ctor_set(x_12, 1, x_13); +lean_ctor_set(x_12, 0, x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_12); +lean_ctor_set(x_19, 1, x_10); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_12, 0); +lean_inc(x_20); +lean_dec(x_12); +lean_ctor_set(x_11, 0, x_20); +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_11); +lean_ctor_set(x_21, 1, x_13); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_10); +return x_22; +} +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_23 = lean_ctor_get(x_11, 1); +lean_inc(x_23); +lean_dec(x_11); +x_24 = lean_ctor_get(x_12, 0); +lean_inc(x_24); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_25 = x_12; +} else { + lean_dec_ref(x_12); + x_25 = lean_box(0); +} +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_23); +if (lean_is_scalar(x_25)) { + x_27 = lean_alloc_ctor(0, 2, 0); +} else { + x_27 = x_25; +} +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_13); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_10); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_9); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_9, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_11); +if (x_31 == 0) +{ +lean_object* x_32; +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_9); +lean_ctor_set(x_32, 1, x_10); +return x_32; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_33 = lean_ctor_get(x_11, 0); +x_34 = lean_ctor_get(x_11, 1); +lean_inc(x_34); +lean_inc(x_33); +lean_dec(x_11); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +lean_ctor_set(x_9, 0, x_35); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_9); +lean_ctor_set(x_36, 1, x_10); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_37 = lean_ctor_get(x_9, 1); +lean_inc(x_37); +lean_dec(x_9); +x_38 = lean_ctor_get(x_11, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_11, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_11)) { + lean_ctor_release(x_11, 0); + lean_ctor_release(x_11, 1); + x_40 = x_11; +} else { + lean_dec_ref(x_11); + x_40 = lean_box(0); +} +if (lean_is_scalar(x_40)) { + x_41 = lean_alloc_ctor(1, 2, 0); +} else { + x_41 = x_40; +} +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_39); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_37); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_10); +return x_43; +} +} +} +} +} +LEAN_EXPORT lean_object* l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__8(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__8___rarg), 8, 0); +return x_2; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_ByteArray_empty; +x_2 = lean_unsigned_to_nat(0u); +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Init.Data.String.Extra", 22); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("String.fromUTF8!", 16); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid UTF-8 string", 20); +return x_1; +} +} +static lean_object* _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5() { +_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_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__2; +x_2 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__3; +x_3 = lean_unsigned_to_nat(92u); +x_4 = lean_unsigned_to_nat(47u); +x_5 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__4; +x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; +x_9 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__1; +x_10 = lean_st_mk_ref(x_9, x_8); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_st_mk_ref(x_9, x_12); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = lean_ctor_get(x_13, 0); +lean_inc(x_14); +x_15 = lean_ctor_get(x_13, 1); +lean_inc(x_15); +lean_dec(x_13); +x_16 = l_IO_FS_Stream_ofBuffer(x_11); +lean_inc(x_14); +x_17 = l_IO_FS_Stream_ofBuffer(x_14); +if (x_2 == 0) +{ +lean_object* x_18; lean_object* x_19; +x_18 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__4___rarg), 8, 2); +lean_closure_set(x_18, 0, x_17); +lean_closure_set(x_18, 1, x_1); +x_19 = l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__5___rarg(x_16, x_18, x_3, x_4, x_5, x_6, x_7, x_15); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; uint8_t x_23; +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = !lean_is_exclusive(x_20); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; uint8_t x_26; +x_24 = lean_ctor_get(x_20, 1); +x_25 = lean_ctor_get(x_20, 0); +lean_dec(x_25); +x_26 = !lean_is_exclusive(x_21); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_21, 0); +x_28 = lean_ctor_get(x_21, 1); +x_29 = lean_st_ref_get(x_14, x_22); +lean_dec(x_14); +if (lean_obj_tag(x_29) == 0) +{ +uint8_t x_30; +x_30 = !lean_is_exclusive(x_29); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; uint8_t x_33; +x_31 = lean_ctor_get(x_29, 0); +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +lean_dec(x_31); +x_33 = lean_string_validate_utf8(x_32); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_32); +x_34 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_35 = l_panic___at_String_fromUTF8_x21___spec__1(x_34); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_35); +lean_ctor_set(x_21, 0, x_20); +x_36 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_36, 0, x_21); +lean_ctor_set(x_36, 1, x_24); +lean_ctor_set(x_29, 0, x_36); +return x_29; +} +else +{ +lean_object* x_37; lean_object* x_38; +x_37 = lean_string_from_utf8(x_32); +lean_dec(x_32); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_37); +lean_ctor_set(x_21, 0, x_20); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_21); +lean_ctor_set(x_38, 1, x_24); +lean_ctor_set(x_29, 0, x_38); +return x_29; +} +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; +x_39 = lean_ctor_get(x_29, 0); +x_40 = lean_ctor_get(x_29, 1); +lean_inc(x_40); +lean_inc(x_39); +lean_dec(x_29); +x_41 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +lean_dec(x_39); +x_42 = lean_string_validate_utf8(x_41); +if (x_42 == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_dec(x_41); +x_43 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_44 = l_panic___at_String_fromUTF8_x21___spec__1(x_43); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_44); +lean_ctor_set(x_21, 0, x_20); +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_21); +lean_ctor_set(x_45, 1, x_24); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_40); +return x_46; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_string_from_utf8(x_41); +lean_dec(x_41); +lean_ctor_set(x_20, 1, x_27); +lean_ctor_set(x_20, 0, x_47); +lean_ctor_set(x_21, 0, x_20); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_21); +lean_ctor_set(x_48, 1, x_24); +x_49 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_40); +return x_49; +} +} +} +else +{ +uint8_t x_50; +lean_free_object(x_21); +lean_dec(x_28); +lean_dec(x_27); +lean_free_object(x_20); +lean_dec(x_24); +x_50 = !lean_is_exclusive(x_29); +if (x_50 == 0) +{ +return x_29; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_29, 0); +x_52 = lean_ctor_get(x_29, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_29); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; +} +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_21, 0); +x_55 = lean_ctor_get(x_21, 1); +lean_inc(x_55); +lean_inc(x_54); +lean_dec(x_21); +x_56 = lean_st_ref_get(x_14, x_22); +lean_dec(x_14); +if (lean_obj_tag(x_56) == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; +x_57 = lean_ctor_get(x_56, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_56, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_56)) { + lean_ctor_release(x_56, 0); + lean_ctor_release(x_56, 1); + x_59 = x_56; +} else { + lean_dec_ref(x_56); + x_59 = lean_box(0); +} +x_60 = lean_ctor_get(x_57, 0); +lean_inc(x_60); +lean_dec(x_57); +x_61 = lean_string_validate_utf8(x_60); +if (x_61 == 0) +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +lean_dec(x_60); +x_62 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_63 = l_panic___at_String_fromUTF8_x21___spec__1(x_62); +lean_ctor_set(x_20, 1, x_54); +lean_ctor_set(x_20, 0, x_63); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_20); +lean_ctor_set(x_64, 1, x_55); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_24); +if (lean_is_scalar(x_59)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_59; +} +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_58); +return x_66; +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_67 = lean_string_from_utf8(x_60); +lean_dec(x_60); +lean_ctor_set(x_20, 1, x_54); +lean_ctor_set(x_20, 0, x_67); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_20); +lean_ctor_set(x_68, 1, x_55); +x_69 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_24); +if (lean_is_scalar(x_59)) { + x_70 = lean_alloc_ctor(0, 2, 0); +} else { + x_70 = x_59; +} +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_58); +return x_70; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_55); +lean_dec(x_54); +lean_free_object(x_20); +lean_dec(x_24); +x_71 = lean_ctor_get(x_56, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_56, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_56)) { + lean_ctor_release(x_56, 0); + lean_ctor_release(x_56, 1); + x_73 = x_56; +} else { + lean_dec_ref(x_56); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(1, 2, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_71); +lean_ctor_set(x_74, 1, x_72); +return x_74; +} +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); +lean_dec(x_20); +x_76 = lean_ctor_get(x_21, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_21, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_78 = x_21; +} else { + lean_dec_ref(x_21); + x_78 = lean_box(0); +} +x_79 = lean_st_ref_get(x_14, x_22); +lean_dec(x_14); +if (lean_obj_tag(x_79) == 0) +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; uint8_t x_84; +x_80 = lean_ctor_get(x_79, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_79, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_82 = x_79; +} else { + lean_dec_ref(x_79); + x_82 = lean_box(0); +} +x_83 = lean_ctor_get(x_80, 0); +lean_inc(x_83); +lean_dec(x_80); +x_84 = lean_string_validate_utf8(x_83); +if (x_84 == 0) +{ +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_dec(x_83); +x_85 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_86 = l_panic___at_String_fromUTF8_x21___spec__1(x_85); +x_87 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_76); +if (lean_is_scalar(x_78)) { + x_88 = lean_alloc_ctor(0, 2, 0); +} else { + x_88 = x_78; +} +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_77); +x_89 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_75); +if (lean_is_scalar(x_82)) { + x_90 = lean_alloc_ctor(0, 2, 0); +} else { + x_90 = x_82; +} +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_81); +return x_90; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_91 = lean_string_from_utf8(x_83); +lean_dec(x_83); +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_76); +if (lean_is_scalar(x_78)) { + x_93 = lean_alloc_ctor(0, 2, 0); +} else { + x_93 = x_78; +} +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_77); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_75); +if (lean_is_scalar(x_82)) { + x_95 = lean_alloc_ctor(0, 2, 0); +} else { + x_95 = x_82; +} +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_81); +return x_95; +} +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; +lean_dec(x_78); +lean_dec(x_77); +lean_dec(x_76); +lean_dec(x_75); +x_96 = lean_ctor_get(x_79, 0); +lean_inc(x_96); +x_97 = lean_ctor_get(x_79, 1); +lean_inc(x_97); +if (lean_is_exclusive(x_79)) { + lean_ctor_release(x_79, 0); + lean_ctor_release(x_79, 1); + x_98 = x_79; +} else { + lean_dec_ref(x_79); + x_98 = lean_box(0); +} +if (lean_is_scalar(x_98)) { + x_99 = lean_alloc_ctor(1, 2, 0); +} else { + x_99 = x_98; +} +lean_ctor_set(x_99, 0, x_96); +lean_ctor_set(x_99, 1, x_97); +return x_99; +} +} +} +else +{ +uint8_t x_100; +lean_dec(x_14); +x_100 = !lean_is_exclusive(x_19); +if (x_100 == 0) +{ +lean_object* x_101; uint8_t x_102; +x_101 = lean_ctor_get(x_19, 0); +lean_dec(x_101); +x_102 = !lean_is_exclusive(x_20); +if (x_102 == 0) +{ +lean_object* x_103; uint8_t x_104; +x_103 = lean_ctor_get(x_20, 0); +lean_dec(x_103); +x_104 = !lean_is_exclusive(x_21); +if (x_104 == 0) +{ +return x_19; +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_105 = lean_ctor_get(x_21, 0); +x_106 = lean_ctor_get(x_21, 1); +lean_inc(x_106); +lean_inc(x_105); +lean_dec(x_21); +x_107 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_107, 0, x_105); +lean_ctor_set(x_107, 1, x_106); +lean_ctor_set(x_20, 0, x_107); +return x_19; +} +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_108 = lean_ctor_get(x_20, 1); +lean_inc(x_108); +lean_dec(x_20); +x_109 = lean_ctor_get(x_21, 0); +lean_inc(x_109); +x_110 = lean_ctor_get(x_21, 1); +lean_inc(x_110); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_111 = x_21; +} else { + lean_dec_ref(x_21); + x_111 = lean_box(0); +} +if (lean_is_scalar(x_111)) { + x_112 = lean_alloc_ctor(1, 2, 0); +} else { + x_112 = x_111; +} +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_110); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_112); +lean_ctor_set(x_113, 1, x_108); +lean_ctor_set(x_19, 0, x_113); +return x_19; +} +} +else +{ +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; +x_114 = lean_ctor_get(x_19, 1); +lean_inc(x_114); +lean_dec(x_19); +x_115 = lean_ctor_get(x_20, 1); +lean_inc(x_115); +if (lean_is_exclusive(x_20)) { + lean_ctor_release(x_20, 0); + lean_ctor_release(x_20, 1); + x_116 = x_20; +} else { + lean_dec_ref(x_20); + x_116 = lean_box(0); +} +x_117 = lean_ctor_get(x_21, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_21, 1); +lean_inc(x_118); +if (lean_is_exclusive(x_21)) { + lean_ctor_release(x_21, 0); + lean_ctor_release(x_21, 1); + x_119 = x_21; +} else { + lean_dec_ref(x_21); + x_119 = lean_box(0); +} +if (lean_is_scalar(x_119)) { + x_120 = lean_alloc_ctor(1, 2, 0); +} else { + x_120 = x_119; +} +lean_ctor_set(x_120, 0, x_117); +lean_ctor_set(x_120, 1, x_118); +if (lean_is_scalar(x_116)) { + x_121 = lean_alloc_ctor(0, 2, 0); +} else { + x_121 = x_116; +} +lean_ctor_set(x_121, 0, x_120); +lean_ctor_set(x_121, 1, x_115); +x_122 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_122, 0, x_121); +lean_ctor_set(x_122, 1, x_114); +return x_122; +} +} +} +else +{ +uint8_t x_123; +lean_dec(x_14); +x_123 = !lean_is_exclusive(x_19); +if (x_123 == 0) +{ +return x_19; +} +else +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; +x_124 = lean_ctor_get(x_19, 0); +x_125 = lean_ctor_get(x_19, 1); +lean_inc(x_125); +lean_inc(x_124); +lean_dec(x_19); +x_126 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_126, 0, x_124); +lean_ctor_set(x_126, 1, x_125); +return x_126; +} +} +} +else +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; +lean_inc(x_17); +x_127 = lean_alloc_closure((void*)(l_IO_withStderr___at_Lake_Workspace_runFetchM___spec__6___rarg), 8, 2); +lean_closure_set(x_127, 0, x_17); +lean_closure_set(x_127, 1, x_1); +x_128 = lean_alloc_closure((void*)(l_IO_withStdout___at_Lake_Workspace_runFetchM___spec__7___rarg), 8, 2); +lean_closure_set(x_128, 0, x_17); +lean_closure_set(x_128, 1, x_127); +x_129 = l_IO_withStdin___at_Lake_Workspace_runFetchM___spec__8___rarg(x_16, x_128, x_3, x_4, x_5, x_6, x_7, x_15); +if (lean_obj_tag(x_129) == 0) +{ +lean_object* x_130; lean_object* x_131; +x_130 = lean_ctor_get(x_129, 0); +lean_inc(x_130); +x_131 = lean_ctor_get(x_130, 0); +lean_inc(x_131); +if (lean_obj_tag(x_131) == 0) +{ +lean_object* x_132; uint8_t x_133; +x_132 = lean_ctor_get(x_129, 1); +lean_inc(x_132); +lean_dec(x_129); +x_133 = !lean_is_exclusive(x_130); +if (x_133 == 0) +{ +lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_134 = lean_ctor_get(x_130, 1); +x_135 = lean_ctor_get(x_130, 0); +lean_dec(x_135); +x_136 = !lean_is_exclusive(x_131); +if (x_136 == 0) +{ +lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_137 = lean_ctor_get(x_131, 0); +x_138 = lean_ctor_get(x_131, 1); +x_139 = lean_st_ref_get(x_14, x_132); +lean_dec(x_14); +if (lean_obj_tag(x_139) == 0) +{ +uint8_t x_140; +x_140 = !lean_is_exclusive(x_139); +if (x_140 == 0) +{ +lean_object* x_141; lean_object* x_142; uint8_t x_143; +x_141 = lean_ctor_get(x_139, 0); +x_142 = lean_ctor_get(x_141, 0); +lean_inc(x_142); +lean_dec(x_141); +x_143 = lean_string_validate_utf8(x_142); +if (x_143 == 0) +{ +lean_object* x_144; lean_object* x_145; lean_object* x_146; +lean_dec(x_142); +x_144 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_145 = l_panic___at_String_fromUTF8_x21___spec__1(x_144); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_145); +lean_ctor_set(x_131, 0, x_130); +x_146 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_146, 0, x_131); +lean_ctor_set(x_146, 1, x_134); +lean_ctor_set(x_139, 0, x_146); +return x_139; +} +else +{ +lean_object* x_147; lean_object* x_148; +x_147 = lean_string_from_utf8(x_142); +lean_dec(x_142); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_147); +lean_ctor_set(x_131, 0, x_130); +x_148 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_148, 0, x_131); +lean_ctor_set(x_148, 1, x_134); +lean_ctor_set(x_139, 0, x_148); +return x_139; +} +} +else +{ +lean_object* x_149; lean_object* x_150; lean_object* x_151; uint8_t x_152; +x_149 = lean_ctor_get(x_139, 0); +x_150 = lean_ctor_get(x_139, 1); +lean_inc(x_150); +lean_inc(x_149); +lean_dec(x_139); +x_151 = lean_ctor_get(x_149, 0); +lean_inc(x_151); +lean_dec(x_149); +x_152 = lean_string_validate_utf8(x_151); +if (x_152 == 0) +{ +lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; +lean_dec(x_151); +x_153 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_154 = l_panic___at_String_fromUTF8_x21___spec__1(x_153); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_154); +lean_ctor_set(x_131, 0, x_130); +x_155 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_155, 0, x_131); +lean_ctor_set(x_155, 1, x_134); +x_156 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_156, 0, x_155); +lean_ctor_set(x_156, 1, x_150); +return x_156; +} +else +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; +x_157 = lean_string_from_utf8(x_151); +lean_dec(x_151); +lean_ctor_set(x_130, 1, x_137); +lean_ctor_set(x_130, 0, x_157); +lean_ctor_set(x_131, 0, x_130); +x_158 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_158, 0, x_131); +lean_ctor_set(x_158, 1, x_134); +x_159 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_150); +return x_159; +} +} +} +else +{ +uint8_t x_160; +lean_free_object(x_131); +lean_dec(x_138); +lean_dec(x_137); +lean_free_object(x_130); +lean_dec(x_134); +x_160 = !lean_is_exclusive(x_139); +if (x_160 == 0) +{ +return x_139; +} +else +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; +x_161 = lean_ctor_get(x_139, 0); +x_162 = lean_ctor_get(x_139, 1); +lean_inc(x_162); +lean_inc(x_161); +lean_dec(x_139); +x_163 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_163, 0, x_161); +lean_ctor_set(x_163, 1, x_162); +return x_163; +} +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; +x_164 = lean_ctor_get(x_131, 0); +x_165 = lean_ctor_get(x_131, 1); +lean_inc(x_165); +lean_inc(x_164); +lean_dec(x_131); +x_166 = lean_st_ref_get(x_14, x_132); +lean_dec(x_14); +if (lean_obj_tag(x_166) == 0) +{ +lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; +x_167 = lean_ctor_get(x_166, 0); +lean_inc(x_167); +x_168 = lean_ctor_get(x_166, 1); +lean_inc(x_168); +if (lean_is_exclusive(x_166)) { + lean_ctor_release(x_166, 0); + lean_ctor_release(x_166, 1); + x_169 = x_166; +} else { + lean_dec_ref(x_166); + x_169 = lean_box(0); +} +x_170 = lean_ctor_get(x_167, 0); +lean_inc(x_170); +lean_dec(x_167); +x_171 = lean_string_validate_utf8(x_170); +if (x_171 == 0) +{ +lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; +lean_dec(x_170); +x_172 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_173 = l_panic___at_String_fromUTF8_x21___spec__1(x_172); +lean_ctor_set(x_130, 1, x_164); +lean_ctor_set(x_130, 0, x_173); +x_174 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_174, 0, x_130); +lean_ctor_set(x_174, 1, x_165); +x_175 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_175, 0, x_174); +lean_ctor_set(x_175, 1, x_134); +if (lean_is_scalar(x_169)) { + x_176 = lean_alloc_ctor(0, 2, 0); +} else { + x_176 = x_169; +} +lean_ctor_set(x_176, 0, x_175); +lean_ctor_set(x_176, 1, x_168); +return x_176; +} +else +{ +lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_177 = lean_string_from_utf8(x_170); +lean_dec(x_170); +lean_ctor_set(x_130, 1, x_164); +lean_ctor_set(x_130, 0, x_177); +x_178 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_178, 0, x_130); +lean_ctor_set(x_178, 1, x_165); +x_179 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_179, 0, x_178); +lean_ctor_set(x_179, 1, x_134); +if (lean_is_scalar(x_169)) { + x_180 = lean_alloc_ctor(0, 2, 0); +} else { + x_180 = x_169; +} +lean_ctor_set(x_180, 0, x_179); +lean_ctor_set(x_180, 1, x_168); +return x_180; +} +} +else +{ +lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; +lean_dec(x_165); +lean_dec(x_164); +lean_free_object(x_130); +lean_dec(x_134); +x_181 = lean_ctor_get(x_166, 0); +lean_inc(x_181); +x_182 = lean_ctor_get(x_166, 1); +lean_inc(x_182); +if (lean_is_exclusive(x_166)) { + lean_ctor_release(x_166, 0); + lean_ctor_release(x_166, 1); + x_183 = x_166; +} else { + lean_dec_ref(x_166); + x_183 = lean_box(0); +} +if (lean_is_scalar(x_183)) { + x_184 = lean_alloc_ctor(1, 2, 0); +} else { + x_184 = x_183; +} +lean_ctor_set(x_184, 0, x_181); +lean_ctor_set(x_184, 1, x_182); +return x_184; +} +} +} +else +{ +lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; +x_185 = lean_ctor_get(x_130, 1); +lean_inc(x_185); +lean_dec(x_130); +x_186 = lean_ctor_get(x_131, 0); +lean_inc(x_186); +x_187 = lean_ctor_get(x_131, 1); +lean_inc(x_187); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_188 = x_131; +} else { + lean_dec_ref(x_131); + x_188 = lean_box(0); +} +x_189 = lean_st_ref_get(x_14, x_132); +lean_dec(x_14); +if (lean_obj_tag(x_189) == 0) +{ +lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; uint8_t x_194; +x_190 = lean_ctor_get(x_189, 0); +lean_inc(x_190); +x_191 = lean_ctor_get(x_189, 1); +lean_inc(x_191); +if (lean_is_exclusive(x_189)) { + lean_ctor_release(x_189, 0); + lean_ctor_release(x_189, 1); + x_192 = x_189; +} else { + lean_dec_ref(x_189); + x_192 = lean_box(0); +} +x_193 = lean_ctor_get(x_190, 0); +lean_inc(x_193); +lean_dec(x_190); +x_194 = lean_string_validate_utf8(x_193); +if (x_194 == 0) +{ +lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +lean_dec(x_193); +x_195 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5; +x_196 = l_panic___at_String_fromUTF8_x21___spec__1(x_195); +x_197 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_197, 0, x_196); +lean_ctor_set(x_197, 1, x_186); +if (lean_is_scalar(x_188)) { + x_198 = lean_alloc_ctor(0, 2, 0); +} else { + x_198 = x_188; +} +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_187); +x_199 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_199, 0, x_198); +lean_ctor_set(x_199, 1, x_185); +if (lean_is_scalar(x_192)) { + x_200 = lean_alloc_ctor(0, 2, 0); +} else { + x_200 = x_192; +} +lean_ctor_set(x_200, 0, x_199); +lean_ctor_set(x_200, 1, x_191); +return x_200; +} +else +{ +lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; +x_201 = lean_string_from_utf8(x_193); +lean_dec(x_193); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_201); +lean_ctor_set(x_202, 1, x_186); +if (lean_is_scalar(x_188)) { + x_203 = lean_alloc_ctor(0, 2, 0); +} else { + x_203 = x_188; +} +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_187); +x_204 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_204, 0, x_203); +lean_ctor_set(x_204, 1, x_185); +if (lean_is_scalar(x_192)) { + x_205 = lean_alloc_ctor(0, 2, 0); +} else { + x_205 = x_192; +} +lean_ctor_set(x_205, 0, x_204); +lean_ctor_set(x_205, 1, x_191); +return x_205; +} +} +else +{ +lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; +lean_dec(x_188); +lean_dec(x_187); +lean_dec(x_186); +lean_dec(x_185); +x_206 = lean_ctor_get(x_189, 0); +lean_inc(x_206); +x_207 = lean_ctor_get(x_189, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_189)) { + lean_ctor_release(x_189, 0); + lean_ctor_release(x_189, 1); + x_208 = x_189; +} else { + lean_dec_ref(x_189); + x_208 = lean_box(0); +} +if (lean_is_scalar(x_208)) { + x_209 = lean_alloc_ctor(1, 2, 0); +} else { + x_209 = x_208; +} +lean_ctor_set(x_209, 0, x_206); +lean_ctor_set(x_209, 1, x_207); +return x_209; +} +} +} +else +{ +uint8_t x_210; +lean_dec(x_14); +x_210 = !lean_is_exclusive(x_129); +if (x_210 == 0) +{ +lean_object* x_211; uint8_t x_212; +x_211 = lean_ctor_get(x_129, 0); +lean_dec(x_211); +x_212 = !lean_is_exclusive(x_130); +if (x_212 == 0) +{ +lean_object* x_213; uint8_t x_214; +x_213 = lean_ctor_get(x_130, 0); +lean_dec(x_213); +x_214 = !lean_is_exclusive(x_131); +if (x_214 == 0) +{ +return x_129; +} +else +{ +lean_object* x_215; lean_object* x_216; lean_object* x_217; +x_215 = lean_ctor_get(x_131, 0); +x_216 = lean_ctor_get(x_131, 1); +lean_inc(x_216); +lean_inc(x_215); +lean_dec(x_131); +x_217 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_217, 0, x_215); +lean_ctor_set(x_217, 1, x_216); +lean_ctor_set(x_130, 0, x_217); +return x_129; +} +} +else +{ +lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; +x_218 = lean_ctor_get(x_130, 1); +lean_inc(x_218); +lean_dec(x_130); +x_219 = lean_ctor_get(x_131, 0); +lean_inc(x_219); +x_220 = lean_ctor_get(x_131, 1); +lean_inc(x_220); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_221 = x_131; +} else { + lean_dec_ref(x_131); + x_221 = lean_box(0); +} +if (lean_is_scalar(x_221)) { + x_222 = lean_alloc_ctor(1, 2, 0); +} else { + x_222 = x_221; +} +lean_ctor_set(x_222, 0, x_219); +lean_ctor_set(x_222, 1, x_220); +x_223 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_223, 0, x_222); +lean_ctor_set(x_223, 1, x_218); +lean_ctor_set(x_129, 0, x_223); +return x_129; +} +} +else +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +x_224 = lean_ctor_get(x_129, 1); +lean_inc(x_224); +lean_dec(x_129); +x_225 = lean_ctor_get(x_130, 1); +lean_inc(x_225); +if (lean_is_exclusive(x_130)) { + lean_ctor_release(x_130, 0); + lean_ctor_release(x_130, 1); + x_226 = x_130; +} else { + lean_dec_ref(x_130); + x_226 = lean_box(0); +} +x_227 = lean_ctor_get(x_131, 0); +lean_inc(x_227); +x_228 = lean_ctor_get(x_131, 1); +lean_inc(x_228); +if (lean_is_exclusive(x_131)) { + lean_ctor_release(x_131, 0); + lean_ctor_release(x_131, 1); + x_229 = x_131; +} else { + lean_dec_ref(x_131); + x_229 = lean_box(0); +} +if (lean_is_scalar(x_229)) { + x_230 = lean_alloc_ctor(1, 2, 0); +} else { + x_230 = x_229; +} +lean_ctor_set(x_230, 0, x_227); +lean_ctor_set(x_230, 1, x_228); +if (lean_is_scalar(x_226)) { + x_231 = lean_alloc_ctor(0, 2, 0); +} else { + x_231 = x_226; +} +lean_ctor_set(x_231, 0, x_230); +lean_ctor_set(x_231, 1, x_225); +x_232 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_224); +return x_232; +} +} +} +else +{ +uint8_t x_233; +lean_dec(x_14); +x_233 = !lean_is_exclusive(x_129); +if (x_233 == 0) +{ +return x_129; +} +else +{ +lean_object* x_234; lean_object* x_235; lean_object* x_236; +x_234 = lean_ctor_get(x_129, 0); +x_235 = lean_ctor_get(x_129, 1); +lean_inc(x_235); +lean_inc(x_234); +lean_dec(x_129); +x_236 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_236, 0, x_234); +lean_ctor_set(x_236, 1, x_235); +return x_236; +} +} +} +} +else +{ +uint8_t x_237; +lean_dec(x_11); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_237 = !lean_is_exclusive(x_13); +if (x_237 == 0) +{ +return x_13; +} +else +{ +lean_object* x_238; lean_object* x_239; lean_object* x_240; +x_238 = lean_ctor_get(x_13, 0); +x_239 = lean_ctor_get(x_13, 1); +lean_inc(x_239); +lean_inc(x_238); +lean_dec(x_13); +x_240 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_240, 0, x_238); +lean_ctor_set(x_240, 1, x_239); +return x_240; +} +} +} +else +{ +uint8_t x_241; +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_1); +x_241 = !lean_is_exclusive(x_10); +if (x_241 == 0) +{ +return x_10; +} +else +{ +lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_242 = lean_ctor_get(x_10, 0); +x_243 = lean_ctor_get(x_10, 1); +lean_inc(x_243); +lean_inc(x_242); +lean_dec(x_10); +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; +} +} +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___boxed), 8, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("build failed", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__1; +x_2 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Some builds logged failures:\n", 29); +return x_1; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__3; +x_2 = l_String_quote(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__4; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__5; +x_2 = l_Std_Format_defWidth; +x_3 = lean_unsigned_to_nat(0u); +x_4 = lean_format_pretty(x_1, x_2, x_3, x_3); +return x_4; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("top-level build failed", 22); +return x_1; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__8() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__7; +x_2 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Computing build jobs", 20); +return x_1; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__9; +x_2 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1(lean_object* x_1, lean_object* x_2, uint8_t x_3, uint8_t x_4, lean_object* x_5, uint8_t x_6, uint8_t x_7, uint8_t x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +lean_object* x_12; lean_object* x_13; lean_object* x_95; lean_object* x_96; uint8_t x_97; uint8_t x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_95 = lean_array_get_size(x_1); +x_96 = lean_unsigned_to_nat(0u); +x_97 = lean_nat_dec_eq(x_95, x_96); +lean_dec(x_95); +x_98 = l_instDecidableNot___rarg(x_97); +x_99 = lean_ctor_get(x_2, 3); +x_100 = lean_st_ref_get(x_99, x_11); +if (x_98 == 0) +{ +lean_object* x_144; +x_144 = l_Lake_mkBuildContext___closed__1; +x_101 = x_144; +goto block_143; +} +else +{ +uint8_t x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; uint8_t x_149; +x_145 = l_Lake_Log_maxLv(x_1); +x_146 = l_Lake_instOrdLogLevel; +x_147 = lean_box(x_6); +x_148 = lean_box(x_145); +x_149 = l_instDecidableRelLe___rarg(x_146, x_147, x_148); +if (x_149 == 0) +{ +lean_object* x_150; +x_150 = l_Lake_mkBuildContext___closed__1; +x_101 = x_150; +goto block_143; +} +else +{ +lean_object* x_151; +x_151 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__11; +x_101 = x_151; +goto block_143; +} +} +block_94: +{ +lean_object* x_14; uint8_t x_67; +x_67 = l_Array_isEmpty___rarg(x_12); +if (x_67 == 0) +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_5, 4); +lean_inc(x_68); +x_69 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__3; +x_70 = lean_apply_2(x_68, x_69, x_13); +if (lean_obj_tag(x_70) == 0) +{ +lean_object* x_71; +x_71 = lean_ctor_get(x_70, 1); +lean_inc(x_71); +lean_dec(x_70); +x_14 = x_71; +goto block_66; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_72 = lean_ctor_get(x_70, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_70, 1); +lean_inc(x_73); +lean_dec(x_70); +x_74 = lean_io_error_to_string(x_72); +x_75 = l_Lake_print_x21___closed__8; +x_76 = lean_string_append(x_75, x_74); +lean_dec(x_74); +x_77 = l_Lake_print_x21___closed__9; +x_78 = lean_string_append(x_76, x_77); +x_79 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__6; +x_80 = lean_string_append(x_78, x_79); +x_81 = l_Lake_print_x21___closed__10; +x_82 = lean_string_append(x_80, x_81); +x_83 = l_Lake_print_x21___closed__11; +x_84 = l_Lake_print_x21___closed__12; +x_85 = lean_unsigned_to_nat(74u); +x_86 = lean_unsigned_to_nat(4u); +x_87 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_83, x_84, x_85, x_86, x_82); +lean_dec(x_82); +x_88 = l_panic___at_Lake_print_x21___spec__1(x_87, x_73); +x_89 = lean_ctor_get(x_88, 1); +lean_inc(x_89); +lean_dec(x_88); +x_14 = x_89; +goto block_66; +} +} +else +{ +lean_dec(x_12); +lean_dec(x_5); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_90; lean_object* x_91; +x_90 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__8; +x_91 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_13); +return x_91; +} +else +{ +lean_object* x_92; lean_object* x_93; +x_92 = lean_ctor_get(x_9, 0); +lean_inc(x_92); +x_93 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_93, 0, x_92); +lean_ctor_set(x_93, 1, x_13); +return x_93; +} +} +block_66: +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; +x_15 = lean_array_get_size(x_12); +x_16 = lean_unsigned_to_nat(0u); +x_17 = lean_nat_dec_lt(x_16, x_15); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; +lean_dec(x_15); +lean_dec(x_12); +x_18 = lean_ctor_get(x_5, 0); +lean_inc(x_18); +lean_dec(x_5); +x_19 = lean_apply_1(x_18, x_14); +if (lean_obj_tag(x_19) == 0) +{ +uint8_t x_20; +x_20 = !lean_is_exclusive(x_19); +if (x_20 == 0) +{ +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_19, 0); +lean_dec(x_21); +x_22 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set_tag(x_19, 1); +lean_ctor_set(x_19, 0, x_22); +return x_19; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_19, 1); +lean_inc(x_23); +lean_dec(x_19); +x_24 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_23); +return x_25; +} +} +else +{ +uint8_t x_26; +x_26 = !lean_is_exclusive(x_19); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_19, 0); +lean_dec(x_27); +x_28 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set(x_19, 0, x_28); +return x_19; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_19, 1); +lean_inc(x_29); +lean_dec(x_19); +x_30 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_29); +return x_31; +} +} +} +else +{ +uint8_t x_32; +x_32 = lean_nat_dec_le(x_15, x_15); +if (x_32 == 0) +{ +lean_object* x_33; lean_object* x_34; +lean_dec(x_15); +lean_dec(x_12); +x_33 = lean_ctor_get(x_5, 0); +lean_inc(x_33); +lean_dec(x_5); +x_34 = lean_apply_1(x_33, x_14); +if (lean_obj_tag(x_34) == 0) +{ +uint8_t x_35; +x_35 = !lean_is_exclusive(x_34); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; +x_36 = lean_ctor_get(x_34, 0); +lean_dec(x_36); +x_37 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set_tag(x_34, 1); +lean_ctor_set(x_34, 0, x_37); +return x_34; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_34, 1); +lean_inc(x_38); +lean_dec(x_34); +x_39 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_40 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_38); +return x_40; +} +} +else +{ +uint8_t x_41; +x_41 = !lean_is_exclusive(x_34); +if (x_41 == 0) +{ +lean_object* x_42; lean_object* x_43; +x_42 = lean_ctor_get(x_34, 0); +lean_dec(x_42); +x_43 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set(x_34, 0, x_43); +return x_34; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_34, 1); +lean_inc(x_44); +lean_dec(x_34); +x_45 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_44); +return x_46; +} +} +} +else +{ +size_t x_47; size_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_47 = 0; +x_48 = lean_usize_of_nat(x_15); +lean_dec(x_15); +x_49 = lean_box(0); +lean_inc(x_5); +x_50 = l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1(x_5, x_12, x_47, x_48, x_49, x_14); +lean_dec(x_12); +x_51 = lean_ctor_get(x_50, 1); +lean_inc(x_51); +lean_dec(x_50); +x_52 = lean_ctor_get(x_5, 0); +lean_inc(x_52); +lean_dec(x_5); +x_53 = lean_apply_1(x_52, x_51); +if (lean_obj_tag(x_53) == 0) +{ +uint8_t x_54; +x_54 = !lean_is_exclusive(x_53); +if (x_54 == 0) +{ +lean_object* x_55; lean_object* x_56; +x_55 = lean_ctor_get(x_53, 0); +lean_dec(x_55); +x_56 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set_tag(x_53, 1); +lean_ctor_set(x_53, 0, x_56); +return x_53; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_57 = lean_ctor_get(x_53, 1); +lean_inc(x_57); +lean_dec(x_53); +x_58 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_59 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_57); +return x_59; +} +} +else +{ +uint8_t x_60; +x_60 = !lean_is_exclusive(x_53); +if (x_60 == 0) +{ +lean_object* x_61; lean_object* x_62; +x_61 = lean_ctor_get(x_53, 0); +lean_dec(x_61); +x_62 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set(x_53, 0, x_62); +return x_53; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_53, 1); +lean_inc(x_63); +lean_dec(x_53); +x_64 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_63); +return x_65; +} +} +} +} +} +} +block_143: +{ +lean_object* x_102; lean_object* x_103; uint8_t x_104; uint8_t x_105; lean_object* x_106; +x_102 = lean_ctor_get(x_100, 0); +lean_inc(x_102); +x_103 = lean_ctor_get(x_100, 1); +lean_inc(x_103); +lean_dec(x_100); +x_104 = 2; +x_105 = l_Lake_instDecidableEqVerbosity(x_3, x_104); +x_106 = lean_array_get_size(x_102); +if (x_4 == 0) +{ +if (x_105 == 0) +{ +uint8_t x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_107 = 2; +x_108 = l_Lake_print_x21___closed__10; +x_109 = lean_unsigned_to_nat(100u); +lean_inc(x_5); +x_110 = l_Lake_monitorJobs(x_102, x_5, x_6, x_7, x_107, x_8, x_4, x_108, x_101, x_106, x_109, x_103); +x_111 = lean_ctor_get(x_110, 0); +lean_inc(x_111); +x_112 = lean_ctor_get(x_110, 1); +lean_inc(x_112); +lean_dec(x_110); +x_12 = x_111; +x_13 = x_112; +goto block_94; +} +else +{ +uint8_t x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; +x_113 = 0; +x_114 = l_Lake_print_x21___closed__10; +x_115 = lean_unsigned_to_nat(100u); +lean_inc(x_5); +x_116 = l_Lake_monitorJobs(x_102, x_5, x_6, x_7, x_113, x_8, x_4, x_114, x_101, x_106, x_115, x_103); +x_117 = lean_ctor_get(x_116, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_116, 1); +lean_inc(x_118); +lean_dec(x_116); +x_12 = x_117; +x_13 = x_118; +goto block_94; +} +} +else +{ +if (x_8 == 0) +{ +if (x_105 == 0) +{ +uint8_t x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; +x_119 = 2; +x_120 = l_Lake_print_x21___closed__10; +x_121 = lean_unsigned_to_nat(100u); +lean_inc(x_5); +x_122 = l_Lake_monitorJobs(x_102, x_5, x_6, x_7, x_119, x_8, x_4, x_120, x_101, x_106, x_121, x_103); +x_123 = lean_ctor_get(x_122, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_122, 1); +lean_inc(x_124); +lean_dec(x_122); +x_12 = x_123; +x_13 = x_124; +goto block_94; +} +else +{ +uint8_t x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; +x_125 = 0; +x_126 = l_Lake_print_x21___closed__10; +x_127 = lean_unsigned_to_nat(100u); +lean_inc(x_5); +x_128 = l_Lake_monitorJobs(x_102, x_5, x_6, x_7, x_125, x_8, x_4, x_126, x_101, x_106, x_127, x_103); +x_129 = lean_ctor_get(x_128, 0); +lean_inc(x_129); +x_130 = lean_ctor_get(x_128, 1); +lean_inc(x_130); +lean_dec(x_128); +x_12 = x_129; +x_13 = x_130; +goto block_94; +} +} +else +{ +if (x_105 == 0) +{ +uint8_t x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; +x_131 = 2; +x_132 = l_Lake_Ansi_resetLine; +x_133 = lean_unsigned_to_nat(100u); +lean_inc(x_5); +x_134 = l_Lake_monitorJobs(x_102, x_5, x_6, x_7, x_131, x_8, x_4, x_132, x_101, x_106, x_133, x_103); +x_135 = lean_ctor_get(x_134, 0); +lean_inc(x_135); +x_136 = lean_ctor_get(x_134, 1); +lean_inc(x_136); +lean_dec(x_134); +x_12 = x_135; +x_13 = x_136; +goto block_94; +} +else +{ +uint8_t x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; +x_137 = 0; +x_138 = l_Lake_Ansi_resetLine; +x_139 = lean_unsigned_to_nat(100u); +lean_inc(x_5); +x_140 = l_Lake_monitorJobs(x_102, x_5, x_6, x_7, x_137, x_8, x_4, x_138, x_101, x_106, x_139, x_103); +x_141 = lean_ctor_get(x_140, 0); +lean_inc(x_141); +x_142 = lean_ctor_get(x_140, 1); +lean_inc(x_142); +lean_dec(x_140); +x_12 = x_141; +x_13 = x_142; +goto block_94; +} +} +} +} +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Monitor_reportJob___lambda__2___closed__2; +x_2 = l_String_quote(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__1; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__2; +x_2 = l_Std_Format_defWidth; +x_3 = lean_unsigned_to_nat(0u); +x_4 = lean_format_pretty(x_1, x_2, x_3, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, uint8_t x_6, uint8_t x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_1, 4); +lean_inc(x_46); +x_47 = l_Lake_Monitor_reportJob___lambda__2___closed__2; +x_48 = lean_apply_2(x_46, x_47, x_9); +if (lean_obj_tag(x_48) == 0) +{ +lean_object* x_49; +x_49 = lean_ctor_get(x_48, 1); +lean_inc(x_49); +lean_dec(x_48); +x_10 = x_49; +goto block_45; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_50 = lean_ctor_get(x_48, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_48, 1); +lean_inc(x_51); +lean_dec(x_48); +x_52 = lean_io_error_to_string(x_50); +x_53 = l_Lake_print_x21___closed__8; +x_54 = lean_string_append(x_53, x_52); +lean_dec(x_52); +x_55 = l_Lake_print_x21___closed__9; +x_56 = lean_string_append(x_54, x_55); +x_57 = l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__3; +x_58 = lean_string_append(x_56, x_57); +x_59 = l_Lake_print_x21___closed__10; +x_60 = lean_string_append(x_58, x_59); +x_61 = l_Lake_print_x21___closed__11; +x_62 = l_Lake_print_x21___closed__12; +x_63 = lean_unsigned_to_nat(74u); +x_64 = lean_unsigned_to_nat(4u); +x_65 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_61, x_62, x_63, x_64, x_60); +lean_dec(x_60); +x_66 = l_panic___at_Lake_print_x21___spec__1(x_65, x_51); +x_67 = lean_ctor_get(x_66, 1); +lean_inc(x_67); +lean_dec(x_66); +x_10 = x_67; +goto block_45; +} +block_45: +{ +lean_object* x_11; uint8_t x_12; uint8_t x_13; +x_11 = lean_unsigned_to_nat(0u); +x_12 = lean_nat_dec_lt(x_11, x_2); +if (x_6 == 0) +{ +x_13 = x_7; +goto block_43; +} +else +{ +uint8_t x_44; +x_44 = 0; +x_13 = x_44; +goto block_43; +} +block_43: +{ +if (x_12 == 0) +{ +lean_object* x_14; lean_object* x_15; +x_14 = lean_ctor_get(x_1, 0); +lean_inc(x_14); +lean_dec(x_1); +x_15 = lean_apply_1(x_14, x_10); +if (lean_obj_tag(x_15) == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +x_17 = lean_ctor_get(x_15, 1); +lean_inc(x_17); +lean_dec(x_15); +x_18 = lean_apply_2(x_3, x_16, x_17); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_15, 1); +lean_inc(x_19); +lean_dec(x_15); +x_20 = lean_box(0); +x_21 = lean_apply_2(x_3, x_20, x_19); +return x_21; +} +} +else +{ +uint8_t x_22; +x_22 = lean_nat_dec_le(x_2, x_2); +if (x_22 == 0) +{ +lean_object* x_23; lean_object* x_24; +x_23 = lean_ctor_get(x_1, 0); +lean_inc(x_23); +lean_dec(x_1); +x_24 = lean_apply_1(x_23, x_10); +if (lean_obj_tag(x_24) == 0) +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +x_26 = lean_ctor_get(x_24, 1); +lean_inc(x_26); +lean_dec(x_24); +x_27 = lean_apply_2(x_3, x_25, x_26); +return x_27; +} +else +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_28 = lean_ctor_get(x_24, 1); +lean_inc(x_28); +lean_dec(x_24); +x_29 = lean_box(0); +x_30 = lean_apply_2(x_3, x_29, x_28); +return x_30; +} +} +else +{ +size_t x_31; size_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_31 = 0; +x_32 = lean_usize_of_nat(x_2); +x_33 = lean_box(0); +lean_inc(x_1); +x_34 = l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__2(x_1, x_4, x_13, x_5, x_31, x_32, x_33, x_10); +x_35 = lean_ctor_get(x_34, 1); +lean_inc(x_35); +lean_dec(x_34); +x_36 = lean_ctor_get(x_1, 0); +lean_inc(x_36); +lean_dec(x_1); +x_37 = lean_apply_1(x_36, x_35); +if (lean_obj_tag(x_37) == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_37, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_37, 1); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_apply_2(x_3, x_38, x_39); +return x_40; +} +else +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_37, 1); +lean_inc(x_41); +lean_dec(x_37); +x_42 = lean_apply_2(x_3, x_33, x_41); +return x_42; +} +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_9, 0, x_1); +lean_ctor_set(x_9, 1, x_6); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_7); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_8); +return x_11; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__4___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("stdout/stderr:\n", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_dec(x_1); +x_10 = l_String_isEmpty(x_8); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_11 = l_Lake_Workspace_runFetchM___rarg___lambda__4___closed__1; +x_12 = lean_string_append(x_11, x_8); +lean_dec(x_8); +x_13 = l_Lake_print_x21___closed__10; +x_14 = lean_string_append(x_12, x_13); +x_15 = 1; +x_16 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_16, 0, x_14); +lean_ctor_set_uint8(x_16, sizeof(void*)*1, x_15); +x_17 = lean_array_push(x_5, x_16); +x_18 = lean_box(0); +x_19 = l_Lake_Workspace_runFetchM___rarg___lambda__3(x_9, x_18, x_2, x_3, x_4, x_17, x_6, x_7); +return x_19; +} +else +{ +lean_object* x_20; lean_object* x_21; +lean_dec(x_8); +x_20 = lean_box(0); +x_21 = l_Lake_Workspace_runFetchM___rarg___lambda__3(x_9, x_20, x_2, x_3, x_4, x_5, x_6, x_7); +return x_21; +} +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" [\?/\?] ", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_print_x21___closed__10; +x_2 = l_Lake_Ansi_resetLine; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__2; +x_2 = l_Lake_print_x21___closed__10; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Workspace_runFetchM___rarg___lambda__4___boxed), 7, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_recFetch___at_Lake_FetchM_run___spec__7), 6, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, uint8_t x_5, uint8_t x_6, uint8_t x_7, uint8_t x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +lean_object* x_11; lean_object* x_12; uint8_t x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; uint8_t x_159; +x_149 = 1; +x_150 = lean_box(x_149); +x_151 = lean_alloc_closure((void*)(l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___boxed), 8, 2); +lean_closure_set(x_151, 0, x_1); +lean_closure_set(x_151, 1, x_150); +x_152 = lean_box(0); +x_153 = lean_box(0); +x_154 = l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__4; +x_155 = l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__5; +x_156 = l_Lake_mkBuildContext___closed__1; +lean_inc(x_2); +x_157 = l_Lake_EquipT_bind___at_Lake_LeanExe_recBuildExe___spec__6___rarg(x_151, x_154, x_155, x_152, x_2, x_156, x_153, x_10); +x_158 = lean_ctor_get(x_157, 0); +lean_inc(x_158); +x_159 = !lean_is_exclusive(x_158); +if (x_159 == 0) +{ +lean_object* x_160; lean_object* x_161; +x_160 = lean_ctor_get(x_158, 0); +x_161 = lean_ctor_get(x_158, 1); +lean_dec(x_161); +if (lean_obj_tag(x_160) == 0) +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_162 = lean_ctor_get(x_157, 1); +lean_inc(x_162); +lean_dec(x_157); +x_163 = lean_ctor_get(x_160, 0); +lean_inc(x_163); +x_164 = lean_ctor_get(x_160, 1); +lean_inc(x_164); +lean_dec(x_160); +x_165 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_165, 0, x_163); +lean_ctor_set(x_158, 1, x_164); +lean_ctor_set(x_158, 0, x_165); +x_11 = x_158; +x_12 = x_162; +goto block_148; +} +else +{ +lean_object* x_166; lean_object* x_167; lean_object* x_168; +x_166 = lean_ctor_get(x_157, 1); +lean_inc(x_166); +lean_dec(x_157); +x_167 = lean_ctor_get(x_160, 1); +lean_inc(x_167); +lean_dec(x_160); +x_168 = lean_box(0); +lean_ctor_set(x_158, 1, x_167); +lean_ctor_set(x_158, 0, x_168); +x_11 = x_158; +x_12 = x_166; +goto block_148; +} +} +else +{ +lean_object* x_169; +x_169 = lean_ctor_get(x_158, 0); +lean_inc(x_169); +lean_dec(x_158); +if (lean_obj_tag(x_169) == 0) +{ +lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; +x_170 = lean_ctor_get(x_157, 1); +lean_inc(x_170); +lean_dec(x_157); +x_171 = lean_ctor_get(x_169, 0); +lean_inc(x_171); +x_172 = lean_ctor_get(x_169, 1); +lean_inc(x_172); +lean_dec(x_169); +x_173 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_173, 0, x_171); +x_174 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_174, 0, x_173); +lean_ctor_set(x_174, 1, x_172); +x_11 = x_174; +x_12 = x_170; +goto block_148; +} +else +{ +lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; +x_175 = lean_ctor_get(x_157, 1); +lean_inc(x_175); +lean_dec(x_157); +x_176 = lean_ctor_get(x_169, 1); +lean_inc(x_176); +lean_dec(x_169); +x_177 = lean_box(0); +x_178 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_176); +x_11 = x_178; +x_12 = x_175; +goto block_148; +} +} +block_148: +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_11, 1); +lean_inc(x_14); +lean_dec(x_11); +x_15 = lean_box(x_4); +x_16 = lean_box(x_5); +x_17 = lean_box(x_6); +x_18 = lean_box(x_7); +x_19 = lean_box(x_8); +lean_inc(x_13); +lean_inc(x_3); +lean_inc(x_2); +lean_inc(x_14); +x_20 = lean_alloc_closure((void*)(l_Lake_Workspace_runFetchM___rarg___lambda__1___boxed), 11, 9); +lean_closure_set(x_20, 0, x_14); +lean_closure_set(x_20, 1, x_2); +lean_closure_set(x_20, 2, x_15); +lean_closure_set(x_20, 3, x_16); +lean_closure_set(x_20, 4, x_3); +lean_closure_set(x_20, 5, x_17); +lean_closure_set(x_20, 6, x_18); +lean_closure_set(x_20, 7, x_19); +lean_closure_set(x_20, 8, x_13); +x_21 = lean_array_get_size(x_14); +x_22 = lean_unsigned_to_nat(0u); +x_23 = lean_nat_dec_eq(x_21, x_22); +x_24 = l_instDecidableNot___rarg(x_23); +if (x_24 == 0) +{ +uint8_t x_146; +x_146 = 0; +x_25 = x_146; +goto block_145; +} +else +{ +uint8_t x_147; +x_147 = 1; +x_25 = x_147; +goto block_145; +} +block_145: +{ +uint8_t x_26; +if (x_25 == 0) +{ +uint8_t x_137; +x_137 = 0; +x_26 = x_137; +goto block_136; +} +else +{ +uint8_t x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; uint8_t x_142; +x_138 = l_Lake_Log_maxLv(x_14); +x_139 = l_Lake_instOrdLogLevel; +x_140 = lean_box(x_6); +x_141 = lean_box(x_138); +x_142 = l_instDecidableRelLe___rarg(x_139, x_140, x_141); +if (x_142 == 0) +{ +uint8_t x_143; +x_143 = 0; +x_26 = x_143; +goto block_136; +} +else +{ +uint8_t x_144; +x_144 = 1; +x_26 = x_144; +goto block_136; +} +} +block_136: +{ +lean_object* x_27; +if (x_26 == 0) +{ +if (x_25 == 0) +{ +lean_object* x_125; lean_object* x_126; +lean_dec(x_21); +lean_dec(x_20); +x_125 = lean_box(0); +x_126 = l_Lake_Workspace_runFetchM___rarg___lambda__1(x_14, x_2, x_4, x_5, x_3, x_6, x_7, x_8, x_13, x_125, x_12); +lean_dec(x_13); +lean_dec(x_2); +lean_dec(x_14); +return x_126; +} +else +{ +uint8_t x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; +x_127 = l_Lake_Log_maxLv(x_14); +x_128 = l_Lake_instOrdLogLevel; +x_129 = lean_box(x_7); +x_130 = lean_box(x_127); +x_131 = l_instDecidableRelLe___rarg(x_128, x_129, x_130); +if (x_131 == 0) +{ +lean_object* x_132; lean_object* x_133; +lean_dec(x_21); +lean_dec(x_20); +x_132 = lean_box(0); +x_133 = l_Lake_Workspace_runFetchM___rarg___lambda__1(x_14, x_2, x_4, x_5, x_3, x_6, x_7, x_8, x_13, x_132, x_12); +lean_dec(x_13); +lean_dec(x_2); +lean_dec(x_14); +return x_133; +} +else +{ +lean_object* x_134; +lean_dec(x_13); +lean_dec(x_2); +x_134 = lean_box(0); +x_27 = x_134; +goto block_124; +} +} +} +else +{ +lean_object* x_135; +lean_dec(x_13); +lean_dec(x_2); +x_135 = lean_box(0); +x_27 = x_135; +goto block_124; +} +block_124: +{ +uint8_t x_28; uint32_t x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_27); +x_28 = l_Lake_Log_maxLv(x_14); +x_29 = l_Lake_LogLevel_icon(x_28); +x_30 = l_Lake_print_x21___closed__10; +x_31 = lean_string_push(x_30, x_29); +x_32 = lean_string_append(x_30, x_31); +lean_dec(x_31); +x_33 = l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__1; +x_34 = lean_string_append(x_32, x_33); +x_35 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10; +x_36 = lean_string_append(x_34, x_35); +x_37 = lean_string_append(x_36, x_30); +if (x_8 == 0) +{ +lean_object* x_38; lean_object* x_39; +x_38 = lean_ctor_get(x_3, 4); +lean_inc(x_38); +lean_inc(x_37); +x_39 = lean_apply_2(x_38, x_37, x_12); +if (lean_obj_tag(x_39) == 0) +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +lean_dec(x_37); +x_40 = lean_ctor_get(x_39, 0); +lean_inc(x_40); +x_41 = lean_ctor_get(x_39, 1); +lean_inc(x_41); +lean_dec(x_39); +x_42 = l_Lake_Workspace_runFetchM___rarg___lambda__2(x_3, x_21, x_20, x_8, x_14, x_26, x_7, x_40, x_41); +lean_dec(x_40); +lean_dec(x_14); +lean_dec(x_21); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_43 = lean_ctor_get(x_39, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_39, 1); +lean_inc(x_44); +lean_dec(x_39); +x_45 = lean_io_error_to_string(x_43); +x_46 = l_Lake_print_x21___closed__8; +x_47 = lean_string_append(x_46, x_45); +lean_dec(x_45); +x_48 = l_Lake_print_x21___closed__9; +x_49 = lean_string_append(x_47, x_48); +x_50 = l_String_quote(x_37); +lean_dec(x_37); +x_51 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_51, 0, x_50); +x_52 = l_Std_Format_defWidth; +x_53 = lean_format_pretty(x_51, x_52, x_22, x_22); +x_54 = lean_string_append(x_49, x_53); +lean_dec(x_53); +x_55 = lean_string_append(x_54, x_30); +x_56 = l_Lake_print_x21___closed__11; +x_57 = l_Lake_print_x21___closed__12; +x_58 = lean_unsigned_to_nat(74u); +x_59 = lean_unsigned_to_nat(4u); +x_60 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_56, x_57, x_58, x_59, x_55); +lean_dec(x_55); +x_61 = l_panic___at_Lake_print_x21___spec__1(x_60, x_44); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_61, 1); +lean_inc(x_63); +lean_dec(x_61); +x_64 = l_Lake_Workspace_runFetchM___rarg___lambda__2(x_3, x_21, x_20, x_8, x_14, x_26, x_7, x_62, x_63); +lean_dec(x_62); +lean_dec(x_14); +lean_dec(x_21); +return x_64; +} +} +else +{ +lean_object* x_65; lean_object* x_66; +x_65 = l_Lake_LogLevel_ansiColor(x_28); +x_66 = l_Lake_Ansi_chalk(x_65, x_37); +lean_dec(x_37); +lean_dec(x_65); +if (x_5 == 0) +{ +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_3, 4); +lean_inc(x_67); +lean_inc(x_66); +x_68 = lean_apply_2(x_67, x_66, x_12); +if (lean_obj_tag(x_68) == 0) +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +lean_dec(x_66); +x_69 = lean_ctor_get(x_68, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_68, 1); +lean_inc(x_70); +lean_dec(x_68); +x_71 = l_Lake_Workspace_runFetchM___rarg___lambda__2(x_3, x_21, x_20, x_8, x_14, x_26, x_7, x_69, x_70); +lean_dec(x_69); +lean_dec(x_14); +lean_dec(x_21); +return x_71; +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_72 = lean_ctor_get(x_68, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_68, 1); +lean_inc(x_73); +lean_dec(x_68); +x_74 = lean_io_error_to_string(x_72); +x_75 = l_Lake_print_x21___closed__8; +x_76 = lean_string_append(x_75, x_74); +lean_dec(x_74); +x_77 = l_Lake_print_x21___closed__9; +x_78 = lean_string_append(x_76, x_77); +x_79 = l_String_quote(x_66); +lean_dec(x_66); +x_80 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_80, 0, x_79); +x_81 = l_Std_Format_defWidth; +x_82 = lean_format_pretty(x_80, x_81, x_22, x_22); +x_83 = lean_string_append(x_78, x_82); +lean_dec(x_82); +x_84 = lean_string_append(x_83, x_30); +x_85 = l_Lake_print_x21___closed__11; +x_86 = l_Lake_print_x21___closed__12; +x_87 = lean_unsigned_to_nat(74u); +x_88 = lean_unsigned_to_nat(4u); +x_89 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_85, x_86, x_87, x_88, x_84); +lean_dec(x_84); +x_90 = l_panic___at_Lake_print_x21___spec__1(x_89, x_73); +x_91 = lean_ctor_get(x_90, 0); +lean_inc(x_91); +x_92 = lean_ctor_get(x_90, 1); +lean_inc(x_92); +lean_dec(x_90); +x_93 = l_Lake_Workspace_runFetchM___rarg___lambda__2(x_3, x_21, x_20, x_8, x_14, x_26, x_7, x_91, x_92); +lean_dec(x_91); +lean_dec(x_14); +lean_dec(x_21); +return x_93; +} +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_94 = l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__3; +x_95 = lean_string_append(x_94, x_66); +lean_dec(x_66); +x_96 = lean_string_append(x_95, x_30); +x_97 = lean_ctor_get(x_3, 4); +lean_inc(x_97); +lean_inc(x_96); +x_98 = lean_apply_2(x_97, x_96, x_12); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +lean_dec(x_96); +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_Lake_Workspace_runFetchM___rarg___lambda__2(x_3, x_21, x_20, x_8, x_14, x_26, x_7, x_99, x_100); +lean_dec(x_99); +lean_dec(x_14); +lean_dec(x_21); +return x_101; +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_102 = lean_ctor_get(x_98, 0); +lean_inc(x_102); +x_103 = lean_ctor_get(x_98, 1); +lean_inc(x_103); +lean_dec(x_98); +x_104 = lean_io_error_to_string(x_102); +x_105 = l_Lake_print_x21___closed__8; +x_106 = lean_string_append(x_105, x_104); +lean_dec(x_104); +x_107 = l_Lake_print_x21___closed__9; +x_108 = lean_string_append(x_106, x_107); +x_109 = l_String_quote(x_96); +lean_dec(x_96); +x_110 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_110, 0, x_109); +x_111 = l_Std_Format_defWidth; +x_112 = lean_format_pretty(x_110, x_111, x_22, x_22); +x_113 = lean_string_append(x_108, x_112); +lean_dec(x_112); +x_114 = lean_string_append(x_113, x_30); +x_115 = l_Lake_print_x21___closed__11; +x_116 = l_Lake_print_x21___closed__12; +x_117 = lean_unsigned_to_nat(74u); +x_118 = lean_unsigned_to_nat(4u); +x_119 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_115, x_116, x_117, x_118, x_114); +lean_dec(x_114); +x_120 = l_panic___at_Lake_print_x21___spec__1(x_119, x_103); +x_121 = lean_ctor_get(x_120, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_120, 1); +lean_inc(x_122); +lean_dec(x_120); +x_123 = l_Lake_Workspace_runFetchM___rarg___lambda__2(x_3, x_21, x_20, x_8, x_14, x_26, x_7, x_121, x_122); +lean_dec(x_121); +lean_dec(x_14); +lean_dec(x_21); +return x_123; +} +} +} +} +} +} +} +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("⣿ [\?/\?] ", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Workspace_runFetchM___rarg___closed__1; +x_2 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Workspace_runFetchM___rarg___closed__2; +x_2 = l_Lake_print_x21___closed__10; +x_3 = lean_string_append(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Workspace_runFetchM___rarg___closed__3; +x_2 = l_String_quote(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Workspace_runFetchM___rarg___closed__4; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Workspace_runFetchM___rarg___closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = l_Lake_Workspace_runFetchM___rarg___closed__5; +x_2 = l_Std_Format_defWidth; +x_3 = lean_unsigned_to_nat(0u); +x_4 = lean_format_pretty(x_1, x_2, x_3, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; uint8_t x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; +x_5 = lean_ctor_get(x_3, 0); +lean_inc(x_5); +x_6 = l_Lake_OutStream_get(x_5, x_4); +lean_dec(x_5); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_6, 1); +lean_inc(x_8); +lean_dec(x_6); +x_9 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 5); +lean_inc(x_7); +x_10 = l_Lake_AnsiMode_isEnabled(x_7, x_9, x_8); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 3); +x_14 = l_Lake_Verbosity_minLogLv(x_13); +x_15 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 4); +x_16 = l_Lake_BuildConfig_showProgress(x_3); +x_17 = l_Lake_mkBuildContext(x_1, x_3, x_12); +if (x_16 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; +x_18 = lean_ctor_get(x_17, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_17, 1); +lean_inc(x_19); +lean_dec(x_17); +x_20 = lean_box(0); +x_21 = lean_unbox(x_11); +lean_dec(x_11); +x_22 = l_Lake_Workspace_runFetchM___rarg___lambda__5(x_2, x_18, x_7, x_13, x_16, x_15, x_14, x_21, x_20, x_19); +return x_22; +} +else +{ +uint8_t x_23; +x_23 = lean_unbox(x_11); +if (x_23 == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; lean_object* x_28; +x_24 = lean_ctor_get(x_17, 0); +lean_inc(x_24); +x_25 = lean_ctor_get(x_17, 1); +lean_inc(x_25); +lean_dec(x_17); +x_26 = lean_box(0); +x_27 = lean_unbox(x_11); +lean_dec(x_11); +x_28 = l_Lake_Workspace_runFetchM___rarg___lambda__5(x_2, x_24, x_7, x_13, x_16, x_15, x_14, x_27, x_26, x_25); +return x_28; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_29 = lean_ctor_get(x_17, 0); +lean_inc(x_29); +x_30 = lean_ctor_get(x_17, 1); +lean_inc(x_30); +lean_dec(x_17); +x_31 = lean_ctor_get(x_7, 4); +lean_inc(x_31); +x_32 = l_Lake_Workspace_runFetchM___rarg___closed__3; +x_33 = lean_apply_2(x_31, x_32, x_30); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_33, 1); +lean_inc(x_34); +lean_dec(x_33); +x_35 = lean_ctor_get(x_7, 0); +lean_inc(x_35); +x_36 = lean_apply_1(x_35, x_34); +if (lean_obj_tag(x_36) == 0) +{ +lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; +x_37 = lean_ctor_get(x_36, 0); +lean_inc(x_37); +x_38 = lean_ctor_get(x_36, 1); +lean_inc(x_38); +lean_dec(x_36); +x_39 = lean_unbox(x_11); +lean_dec(x_11); +x_40 = l_Lake_Workspace_runFetchM___rarg___lambda__5(x_2, x_29, x_7, x_13, x_16, x_15, x_14, x_39, x_37, x_38); +lean_dec(x_37); +return x_40; +} +else +{ +lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; +x_41 = lean_ctor_get(x_36, 1); +lean_inc(x_41); +lean_dec(x_36); +x_42 = lean_box(0); +x_43 = lean_unbox(x_11); +lean_dec(x_11); +x_44 = l_Lake_Workspace_runFetchM___rarg___lambda__5(x_2, x_29, x_7, x_13, x_16, x_15, x_14, x_43, x_42, x_41); +return x_44; +} +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_45 = lean_ctor_get(x_33, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_33, 1); +lean_inc(x_46); +lean_dec(x_33); +x_47 = lean_io_error_to_string(x_45); +x_48 = l_Lake_print_x21___closed__8; +x_49 = lean_string_append(x_48, x_47); +lean_dec(x_47); +x_50 = l_Lake_print_x21___closed__9; +x_51 = lean_string_append(x_49, x_50); +x_52 = l_Lake_Workspace_runFetchM___rarg___closed__6; +x_53 = lean_string_append(x_51, x_52); +x_54 = l_Lake_print_x21___closed__10; +x_55 = lean_string_append(x_53, x_54); +x_56 = l_Lake_print_x21___closed__11; +x_57 = l_Lake_print_x21___closed__12; +x_58 = lean_unsigned_to_nat(74u); +x_59 = lean_unsigned_to_nat(4u); +x_60 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_56, x_57, x_58, x_59, x_55); +lean_dec(x_55); +x_61 = l_panic___at_Lake_print_x21___spec__1(x_60, x_46); +x_62 = lean_ctor_get(x_61, 1); +lean_inc(x_62); +lean_dec(x_61); +x_63 = lean_ctor_get(x_7, 0); +lean_inc(x_63); +x_64 = lean_apply_1(x_63, x_62); +if (lean_obj_tag(x_64) == 0) +{ +lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; +x_65 = lean_ctor_get(x_64, 0); +lean_inc(x_65); +x_66 = lean_ctor_get(x_64, 1); +lean_inc(x_66); +lean_dec(x_64); +x_67 = lean_unbox(x_11); +lean_dec(x_11); +x_68 = l_Lake_Workspace_runFetchM___rarg___lambda__5(x_2, x_29, x_7, x_13, x_16, x_15, x_14, x_67, x_65, x_66); +lean_dec(x_65); +return x_68; +} +else +{ +lean_object* x_69; lean_object* x_70; uint8_t x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_64, 1); +lean_inc(x_69); +lean_dec(x_64); +x_70 = lean_box(0); +x_71 = lean_unbox(x_11); +lean_dec(x_11); +x_72 = l_Lake_Workspace_runFetchM___rarg___lambda__5(x_2, x_29, x_7, x_13, x_16, x_15, x_14, x_71, x_70, x_69); +return x_72; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Workspace_runFetchM___rarg), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +size_t x_7; size_t x_8; lean_object* x_9; +x_7 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_8 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_9 = l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1(x_1, x_2, x_7, x_8, x_5, x_6); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +uint8_t x_9; uint8_t x_10; size_t x_11; size_t x_12; lean_object* x_13; +x_9 = lean_unbox(x_2); +lean_dec(x_2); +x_10 = lean_unbox(x_3); +lean_dec(x_3); +x_11 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_12 = lean_unbox_usize(x_6); +lean_dec(x_6); +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__2(x_1, x_9, x_10, x_4, x_11, x_12, x_7, x_8); +lean_dec(x_4); +return x_13; +} +} +LEAN_EXPORT lean_object* l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +uint8_t x_9; lean_object* x_10; +x_9 = lean_unbox(x_2); +lean_dec(x_2); +x_10 = l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg(x_1, x_9, x_3, x_4, x_5, x_6, x_7, x_8); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +_start: +{ +uint8_t x_12; uint8_t x_13; uint8_t x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; +x_12 = lean_unbox(x_3); +lean_dec(x_3); +x_13 = lean_unbox(x_4); +lean_dec(x_4); +x_14 = lean_unbox(x_6); +lean_dec(x_6); +x_15 = lean_unbox(x_7); +lean_dec(x_7); +x_16 = lean_unbox(x_8); +lean_dec(x_8); +x_17 = l_Lake_Workspace_runFetchM___rarg___lambda__1(x_1, x_2, x_12, x_13, x_5, x_14, x_15, x_16, x_9, x_10, x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_2); +lean_dec(x_1); +return x_17; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; +x_10 = lean_unbox(x_4); +lean_dec(x_4); +x_11 = lean_unbox(x_6); +lean_dec(x_6); +x_12 = lean_unbox(x_7); +lean_dec(x_7); +x_13 = l_Lake_Workspace_runFetchM___rarg___lambda__2(x_1, x_2, x_3, x_10, x_5, x_11, x_12, x_8, x_9); +lean_dec(x_8); +lean_dec(x_5); +lean_dec(x_2); +return x_13; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_Workspace_runFetchM___rarg___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; +x_8 = l_Lake_Workspace_runFetchM___rarg___lambda__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runFetchM___rarg___lambda__5___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { +_start: +{ +uint8_t x_11; uint8_t x_12; uint8_t x_13; uint8_t x_14; uint8_t x_15; lean_object* x_16; +x_11 = lean_unbox(x_4); +lean_dec(x_4); +x_12 = lean_unbox(x_5); +lean_dec(x_5); +x_13 = lean_unbox(x_6); +lean_dec(x_6); +x_14 = lean_unbox(x_7); +lean_dec(x_7); +x_15 = lean_unbox(x_8); +lean_dec(x_8); +x_16 = l_Lake_Workspace_runFetchM___rarg___lambda__5(x_1, x_2, x_3, x_11, x_12, x_13, x_14, x_15, x_9, x_10); +lean_dec(x_9); +return x_16; +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runBuild___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Workspace_runFetchM___rarg(x_1, x_2, x_3, x_4); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +lean_dec(x_6); +x_9 = lean_io_wait(x_8, x_7); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; uint8_t x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +lean_dec(x_10); +x_12 = !lean_is_exclusive(x_9); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_dec(x_13); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +lean_dec(x_11); +lean_ctor_set(x_9, 0, x_14); +return x_9; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_9, 1); +lean_inc(x_15); +lean_dec(x_9); +x_16 = lean_ctor_get(x_11, 0); +lean_inc(x_16); +lean_dec(x_11); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +return x_17; +} +} +else +{ +uint8_t x_18; +lean_dec(x_10); +x_18 = !lean_is_exclusive(x_9); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_9, 0); +lean_dec(x_19); +x_20 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set_tag(x_9, 1); +lean_ctor_set(x_9, 0, x_20); +return x_9; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_9, 1); +lean_inc(x_21); +lean_dec(x_9); +x_22 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_21); +return x_23; +} +} +} +else +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_5); +if (x_24 == 0) +{ +return x_5; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_5, 0); +x_26 = lean_ctor_get(x_5, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_5); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Workspace_runBuild(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_Workspace_runBuild___rarg), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_runBuild___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Workspace_runFetchM___rarg(x_3, x_1, x_2, x_4); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +x_7 = lean_ctor_get(x_5, 1); +lean_inc(x_7); +lean_dec(x_5); +x_8 = lean_ctor_get(x_6, 0); +lean_inc(x_8); +lean_dec(x_6); +x_9 = lean_io_wait(x_8, x_7); +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; uint8_t x_12; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +lean_dec(x_10); +x_12 = !lean_is_exclusive(x_9); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_9, 0); +lean_dec(x_13); +x_14 = lean_ctor_get(x_11, 0); +lean_inc(x_14); +lean_dec(x_11); +lean_ctor_set(x_9, 0, x_14); +return x_9; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_9, 1); +lean_inc(x_15); +lean_dec(x_9); +x_16 = lean_ctor_get(x_11, 0); +lean_inc(x_16); +lean_dec(x_11); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +return x_17; +} +} +else +{ +uint8_t x_18; +lean_dec(x_10); +x_18 = !lean_is_exclusive(x_9); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_9, 0); +lean_dec(x_19); +x_20 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +lean_ctor_set_tag(x_9, 1); +lean_ctor_set(x_9, 0, x_20); +return x_9; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_9, 1); +lean_inc(x_21); +lean_dec(x_9); +x_22 = l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2; +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_21); +return x_23; +} +} +} +else +{ +uint8_t x_24; +x_24 = !lean_is_exclusive(x_5); +if (x_24 == 0) +{ +return x_5; +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_5, 0); +x_26 = lean_ctor_get(x_5, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_5); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_runBuild(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_runBuild___rarg), 4, 0); +return x_2; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Lock(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Index(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Run(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Lock(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Index(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_mkBuildContext___closed__1 = _init_l_Lake_mkBuildContext___closed__1(); +lean_mark_persistent(l_Lake_mkBuildContext___closed__1); +l_Lake_mkBuildContext___closed__2 = _init_l_Lake_mkBuildContext___closed__2(); +lean_mark_persistent(l_Lake_mkBuildContext___closed__2); +l_Lake_mkBuildContext___closed__3 = _init_l_Lake_mkBuildContext___closed__3(); +lean_mark_persistent(l_Lake_mkBuildContext___closed__3); +l_Lake_Monitor_spinnerFrames___closed__1 = _init_l_Lake_Monitor_spinnerFrames___closed__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__1); +l_Lake_Monitor_spinnerFrames___closed__2___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__2___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__2___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__2 = _init_l_Lake_Monitor_spinnerFrames___closed__2(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__2); +l_Lake_Monitor_spinnerFrames___closed__3___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__3___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__3___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__3 = _init_l_Lake_Monitor_spinnerFrames___closed__3(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__3); +l_Lake_Monitor_spinnerFrames___closed__4___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__4___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__4___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__4 = _init_l_Lake_Monitor_spinnerFrames___closed__4(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__4); +l_Lake_Monitor_spinnerFrames___closed__5___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__5___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__5___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__5 = _init_l_Lake_Monitor_spinnerFrames___closed__5(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__5); +l_Lake_Monitor_spinnerFrames___closed__6___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__6___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__6___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__6 = _init_l_Lake_Monitor_spinnerFrames___closed__6(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__6); +l_Lake_Monitor_spinnerFrames___closed__7___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__7___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__7___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__7 = _init_l_Lake_Monitor_spinnerFrames___closed__7(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__7); +l_Lake_Monitor_spinnerFrames___closed__8___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__8___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__8___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__8 = _init_l_Lake_Monitor_spinnerFrames___closed__8(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__8); +l_Lake_Monitor_spinnerFrames___closed__9___boxed__const__1 = _init_l_Lake_Monitor_spinnerFrames___closed__9___boxed__const__1(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__9___boxed__const__1); +l_Lake_Monitor_spinnerFrames___closed__9 = _init_l_Lake_Monitor_spinnerFrames___closed__9(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames___closed__9); +l_Lake_Monitor_spinnerFrames = _init_l_Lake_Monitor_spinnerFrames(); +lean_mark_persistent(l_Lake_Monitor_spinnerFrames); +l_Lake_MonitorState_jobNo___default = _init_l_Lake_MonitorState_jobNo___default(); +lean_mark_persistent(l_Lake_MonitorState_jobNo___default); +l_Lake_MonitorState_spinnerIdx___default = _init_l_Lake_MonitorState_spinnerIdx___default(); +lean_mark_persistent(l_Lake_MonitorState_spinnerIdx___default); +l_Lake_Ansi_resetLine___closed__1 = _init_l_Lake_Ansi_resetLine___closed__1(); +lean_mark_persistent(l_Lake_Ansi_resetLine___closed__1); +l_Lake_Ansi_resetLine = _init_l_Lake_Ansi_resetLine(); +lean_mark_persistent(l_Lake_Ansi_resetLine); +l_panic___at_Lake_print_x21___spec__1___closed__1 = _init_l_panic___at_Lake_print_x21___spec__1___closed__1(); +lean_mark_persistent(l_panic___at_Lake_print_x21___spec__1___closed__1); +l_Lake_print_x21___closed__1 = _init_l_Lake_print_x21___closed__1(); +lean_mark_persistent(l_Lake_print_x21___closed__1); +l_Lake_print_x21___closed__2 = _init_l_Lake_print_x21___closed__2(); +lean_mark_persistent(l_Lake_print_x21___closed__2); +l_Lake_print_x21___closed__3 = _init_l_Lake_print_x21___closed__3(); +lean_mark_persistent(l_Lake_print_x21___closed__3); +l_Lake_print_x21___closed__4 = _init_l_Lake_print_x21___closed__4(); +lean_mark_persistent(l_Lake_print_x21___closed__4); +l_Lake_print_x21___closed__5 = _init_l_Lake_print_x21___closed__5(); +lean_mark_persistent(l_Lake_print_x21___closed__5); +l_Lake_print_x21___closed__6 = _init_l_Lake_print_x21___closed__6(); +lean_mark_persistent(l_Lake_print_x21___closed__6); +l_Lake_print_x21___closed__7 = _init_l_Lake_print_x21___closed__7(); +lean_mark_persistent(l_Lake_print_x21___closed__7); +l_Lake_print_x21___closed__8 = _init_l_Lake_print_x21___closed__8(); +lean_mark_persistent(l_Lake_print_x21___closed__8); +l_Lake_print_x21___closed__9 = _init_l_Lake_print_x21___closed__9(); +lean_mark_persistent(l_Lake_print_x21___closed__9); +l_Lake_print_x21___closed__10 = _init_l_Lake_print_x21___closed__10(); +lean_mark_persistent(l_Lake_print_x21___closed__10); +l_Lake_print_x21___closed__11 = _init_l_Lake_print_x21___closed__11(); +lean_mark_persistent(l_Lake_print_x21___closed__11); +l_Lake_print_x21___closed__12 = _init_l_Lake_print_x21___closed__12(); +lean_mark_persistent(l_Lake_print_x21___closed__12); +l_Lake_Monitor_renderProgress___closed__1 = _init_l_Lake_Monitor_renderProgress___closed__1(); +lean_mark_persistent(l_Lake_Monitor_renderProgress___closed__1); +l_Lake_Monitor_renderProgress___closed__2 = _init_l_Lake_Monitor_renderProgress___closed__2(); +lean_mark_persistent(l_Lake_Monitor_renderProgress___closed__2); +l_Lake_Monitor_renderProgress___closed__3 = _init_l_Lake_Monitor_renderProgress___closed__3(); +lean_mark_persistent(l_Lake_Monitor_renderProgress___closed__3); +l_Lake_Monitor_renderProgress___closed__4 = _init_l_Lake_Monitor_renderProgress___closed__4(); +lean_mark_persistent(l_Lake_Monitor_renderProgress___closed__4); +l_Lake_Monitor_renderProgress___closed__5 = _init_l_Lake_Monitor_renderProgress___closed__5(); +lean_mark_persistent(l_Lake_Monitor_renderProgress___closed__5); +l_Lake_Monitor_renderProgress___closed__6 = _init_l_Lake_Monitor_renderProgress___closed__6(); +lean_mark_persistent(l_Lake_Monitor_renderProgress___closed__6); +l_Lake_Monitor_reportJob___lambda__2___closed__1 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_Monitor_reportJob___lambda__2___closed__1); +l_Lake_Monitor_reportJob___lambda__2___closed__2 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__2(); +lean_mark_persistent(l_Lake_Monitor_reportJob___lambda__2___closed__2); +l_Lake_Monitor_reportJob___lambda__2___closed__3 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__3(); +lean_mark_persistent(l_Lake_Monitor_reportJob___lambda__2___closed__3); +l_Lake_Monitor_reportJob___lambda__2___closed__4 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__4(); +lean_mark_persistent(l_Lake_Monitor_reportJob___lambda__2___closed__4); +l_Lake_Monitor_reportJob___lambda__2___closed__5 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__5(); +lean_mark_persistent(l_Lake_Monitor_reportJob___lambda__2___closed__5); +l_Lake_Monitor_reportJob___lambda__2___closed__6 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__6(); +lean_mark_persistent(l_Lake_Monitor_reportJob___lambda__2___closed__6); +l_Lake_Monitor_reportJob___lambda__2___closed__7 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__7(); +lean_mark_persistent(l_Lake_Monitor_reportJob___lambda__2___closed__7); +l_Lake_Monitor_reportJob___lambda__2___closed__8 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__8(); +l_Lake_Monitor_reportJob___lambda__2___closed__9 = _init_l_Lake_Monitor_reportJob___lambda__2___closed__9(); +l_Lake_Monitor_poll___closed__1 = _init_l_Lake_Monitor_poll___closed__1(); +lean_mark_persistent(l_Lake_Monitor_poll___closed__1); +l_Lake_Monitor_sleep___closed__1 = _init_l_Lake_Monitor_sleep___closed__1(); +lean_mark_persistent(l_Lake_Monitor_sleep___closed__1); +l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___closed__1 = _init_l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___closed__1(); +lean_mark_persistent(l_Array_foldlMUnsafe_fold___at_Lake_Workspace_runFetchM___spec__1___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__1 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__1(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__1); +l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__2 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__2(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__2); +l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__3 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__3(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__3); +l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__4 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__4(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__4); +l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5 = _init_l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5(); +lean_mark_persistent(l_IO_FS_withIsolatedStreams___at_Lake_Workspace_runFetchM___spec__3___rarg___closed__5); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__1 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__1); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__2); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__3 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__3(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__3); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__4 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__4(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__4); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__5 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__5(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__5); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__6 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__6(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__6); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__7 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__7(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__7); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__8 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__8(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__8); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__9 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__9(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__9); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__10); +l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__11 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__11(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__1___closed__11); +l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__1 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__1); +l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__2 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__2(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__2); +l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__3 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__3(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__2___closed__3); +l_Lake_Workspace_runFetchM___rarg___lambda__4___closed__1 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__4___closed__1(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__4___closed__1); +l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__1 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__1(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__1); +l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__2 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__2(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__2); +l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__3 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__3(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__3); +l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__4 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__4(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__4); +l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__5 = _init_l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__5(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___lambda__5___closed__5); +l_Lake_Workspace_runFetchM___rarg___closed__1 = _init_l_Lake_Workspace_runFetchM___rarg___closed__1(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___closed__1); +l_Lake_Workspace_runFetchM___rarg___closed__2 = _init_l_Lake_Workspace_runFetchM___rarg___closed__2(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___closed__2); +l_Lake_Workspace_runFetchM___rarg___closed__3 = _init_l_Lake_Workspace_runFetchM___rarg___closed__3(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___closed__3); +l_Lake_Workspace_runFetchM___rarg___closed__4 = _init_l_Lake_Workspace_runFetchM___rarg___closed__4(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___closed__4); +l_Lake_Workspace_runFetchM___rarg___closed__5 = _init_l_Lake_Workspace_runFetchM___rarg___closed__5(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___closed__5); +l_Lake_Workspace_runFetchM___rarg___closed__6 = _init_l_Lake_Workspace_runFetchM___rarg___closed__6(); +lean_mark_persistent(l_Lake_Workspace_runFetchM___rarg___closed__6); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Store.c b/stage0/stdlib/Lake/Build/Store.c new file mode 100644 index 0000000000..805174df3b --- /dev/null +++ b/stage0/stdlib/Lake/Build/Store.c @@ -0,0 +1,590 @@ +// Lean compiler output +// Module: Lake.Build.Store +// Imports: Init Lake.Build.Data Lake.Util.StoreInsts +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectPackageFacetArray(lean_object*); +static lean_object* l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__2; +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectSharedExternLibs___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1(lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectTargetFacetArray(lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetArray___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_empty; +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__3; +lean_object* l_Lean_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*); +uint8_t lean_name_eq(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectTargetFacetArray___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetMap(lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectPackageFacetArray___rarg___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__1; +static lean_object* l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Name_mkStr2(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetMap___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetArray(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectSharedExternLibs(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetMap___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetArray___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectTargetFacetArray___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectPackageFacetArray___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* _init_l_Lake_BuildStore_empty() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; +x_4 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_4, 0, x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_2, 3); +lean_inc(x_8); +lean_dec(x_2); +x_9 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg(x_1, x_5, x_3); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get(x_6, 1); +lean_inc(x_11); +lean_dec(x_6); +x_12 = lean_name_eq(x_11, x_1); +lean_dec(x_11); +if (x_12 == 0) +{ +lean_dec(x_7); +x_2 = x_8; +x_3 = x_10; +goto _start; +} +else +{ +lean_object* x_14; +x_14 = lean_array_push(x_10, x_7); +x_2 = x_8; +x_3 = x_14; +goto _start; +} +} +else +{ +lean_object* x_16; +lean_dec(x_7); +lean_dec(x_6); +x_16 = lean_ctor_get(x_9, 0); +lean_inc(x_16); +lean_dec(x_9); +x_2 = x_8; +x_3 = x_16; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg___boxed), 3, 0); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetArray___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1; +x_5 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg(x_2, x_1, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +lean_dec(x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetArray(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildStore_collectModuleFacetArray___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetArray___spec__1___rarg(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetArray___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_BuildStore_collectModuleFacetArray___rarg(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; +x_4 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_4, 0, x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_2, 3); +lean_inc(x_8); +lean_dec(x_2); +x_9 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg(x_1, x_5, x_3); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get(x_6, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_6, 1); +lean_inc(x_12); +lean_dec(x_6); +x_13 = lean_name_eq(x_12, x_1); +lean_dec(x_12); +if (x_13 == 0) +{ +lean_dec(x_11); +lean_dec(x_7); +x_2 = x_8; +x_3 = x_10; +goto _start; +} +else +{ +lean_object* x_15; +x_15 = l_Lean_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(x_10, x_11, x_7); +x_2 = x_8; +x_3 = x_15; +goto _start; +} +} +else +{ +lean_object* x_17; +lean_dec(x_7); +lean_dec(x_6); +x_17 = lean_ctor_get(x_9, 0); +lean_inc(x_17); +lean_dec(x_9); +x_2 = x_8; +x_3 = x_17; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetMap___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_box(0); +x_5 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg(x_2, x_1, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +lean_dec(x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetMap(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildStore_collectModuleFacetMap___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectModuleFacetMap___spec__1___rarg(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectModuleFacetMap___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_BuildStore_collectModuleFacetMap___rarg(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; +x_4 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_4, 0, x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_2, 3); +lean_inc(x_8); +lean_dec(x_2); +x_9 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg(x_1, x_5, x_3); +if (lean_obj_tag(x_6) == 1) +{ +lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get(x_6, 1); +lean_inc(x_11); +lean_dec(x_6); +x_12 = lean_name_eq(x_11, x_1); +lean_dec(x_11); +if (x_12 == 0) +{ +lean_dec(x_7); +x_2 = x_8; +x_3 = x_10; +goto _start; +} +else +{ +lean_object* x_14; +x_14 = lean_array_push(x_10, x_7); +x_2 = x_8; +x_3 = x_14; +goto _start; +} +} +else +{ +lean_object* x_16; +lean_dec(x_7); +lean_dec(x_6); +x_16 = lean_ctor_get(x_9, 0); +lean_inc(x_16); +lean_dec(x_9); +x_2 = x_8; +x_3 = x_16; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectPackageFacetArray___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1; +x_5 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg(x_2, x_1, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +lean_dec(x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectPackageFacetArray(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildStore_collectPackageFacetArray___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectPackageFacetArray___spec__1___rarg(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectPackageFacetArray___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_BuildStore_collectPackageFacetArray___rarg(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; +x_4 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_4, 0, x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +x_7 = lean_ctor_get(x_2, 2); +lean_inc(x_7); +x_8 = lean_ctor_get(x_2, 3); +lean_inc(x_8); +lean_dec(x_2); +x_9 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg(x_1, x_5, x_3); +if (lean_obj_tag(x_6) == 2) +{ +lean_object* x_10; lean_object* x_11; uint8_t x_12; +x_10 = lean_ctor_get(x_9, 0); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_ctor_get(x_6, 2); +lean_inc(x_11); +lean_dec(x_6); +x_12 = lean_name_eq(x_11, x_1); +lean_dec(x_11); +if (x_12 == 0) +{ +lean_dec(x_7); +x_2 = x_8; +x_3 = x_10; +goto _start; +} +else +{ +lean_object* x_14; +x_14 = lean_array_push(x_10, x_7); +x_2 = x_8; +x_3 = x_14; +goto _start; +} +} +else +{ +lean_object* x_16; +lean_dec(x_7); +lean_dec(x_6); +x_16 = lean_ctor_get(x_9, 0); +lean_inc(x_16); +lean_dec(x_9); +x_2 = x_8; +x_3 = x_16; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectTargetFacetArray___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1; +x_5 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg(x_2, x_1, x_4); +x_6 = lean_ctor_get(x_5, 0); +lean_inc(x_6); +lean_dec(x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectTargetFacetArray(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildStore_collectTargetFacetArray___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lean_RBNode_forIn_visit___at_Lake_BuildStore_collectTargetFacetArray___spec__1___rarg(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectTargetFacetArray___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_BuildStore_collectTargetFacetArray___rarg(x_1, x_2, x_3); +lean_dec(x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("externLib", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("shared", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__1; +x_2 = l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__2; +x_3 = l_Lean_Name_mkStr2(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectSharedExternLibs___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__3; +x_4 = l_Lake_BuildStore_collectTargetFacetArray___rarg(x_1, x_3, lean_box(0)); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildStore_collectSharedExternLibs(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildStore_collectSharedExternLibs___rarg), 2, 0); +return x_2; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Data(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_StoreInsts(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Store(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Data(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_StoreInsts(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_BuildStore_empty = _init_l_Lake_BuildStore_empty(); +lean_mark_persistent(l_Lake_BuildStore_empty); +l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1 = _init_l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1(); +lean_mark_persistent(l_Lake_BuildStore_collectModuleFacetArray___rarg___closed__1); +l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__1 = _init_l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__1(); +lean_mark_persistent(l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__1); +l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__2 = _init_l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__2(); +lean_mark_persistent(l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__2); +l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__3 = _init_l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__3(); +lean_mark_persistent(l_Lake_BuildStore_collectSharedExternLibs___rarg___closed__3); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Targets.c b/stage0/stdlib/Lake/Build/Targets.c new file mode 100644 index 0000000000..a69ef6cfd5 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Targets.c @@ -0,0 +1,3364 @@ +// Lean compiler output +// Module: Lake.Build.Targets +// Imports: Init Lake.Config.Monad +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +LEAN_EXPORT lean_object* l_Lake_Package_fetchTargetJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LibraryFacetDecl_fetch___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__1; +static lean_object* l_Lake_Package_fetchTargetJob___closed__1; +static lean_object* l_Lake_Package_fetchTargetJob___closed__2; +static lean_object* l_Lake_LeanExeConfig_get___rarg___lambda__1___closed__1; +LEAN_EXPORT lean_object* l_Lake_Module_fetchFacetJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_PackageFacetDecl_fetch___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_get(lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +lean_object* l_Lake_RBNode_dFind___at_Lake_Workspace_findPackageFacetConfig_x3f___spec__1(lean_object*, lean_object*); +lean_object* lean_array_push(lean_object*, lean_object*); +static lean_object* l_Lake_Package_fetchTargetJob___closed__3; +LEAN_EXPORT lean_object* l_Lake_ModuleFacetDecl_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(lean_object*, lean_object*); +static lean_object* l_Lake_ModuleFacetConfig_fetchJob___closed__1; +static lean_object* l_Lake_Module_fetchFacetJob___closed__1; +LEAN_EXPORT lean_object* l_Lake_LibraryFacetConfig_fetchJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_TargetDecl_fetch(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_PackageFacetDecl_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_fetchFacetJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LibraryFacetDecl_fetch(lean_object*); +LEAN_EXPORT lean_object* l_Lake_PackageFacetDecl_fetch(lean_object*); +lean_object* l_Lake_Package_findTargetConfig_x3f(lean_object*, lean_object*); +lean_object* l_Lake_RBNode_dFind___at_Lake_Workspace_findModuleFacetConfig_x3f___spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_get___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LibraryFacetDecl_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_TargetDecl_fetch___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get(lean_object*); +lean_object* l_Lake_Workspace_findLeanExe_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ModuleFacetDecl_fetch___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ModuleFacetConfig_fetchJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_ModuleFacetDecl_fetch(lean_object*); +LEAN_EXPORT lean_object* l_Lake_TargetDecl_fetchJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Workspace_findLeanExe_x3f___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanExe_fetch(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_fetch(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__1___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_get___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_PackageFacetConfig_fetchJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_RBNode_dFind___at_Lake_Workspace_findLibraryFacetConfig_x3f___spec__1(lean_object*, lean_object*); +static lean_object* l_Lake_TargetDecl_fetch___rarg___closed__2; +static lean_object* l_Lake_PackageFacetConfig_fetchJob___closed__1; +lean_object* l_Lake_Workspace_findLeanLib_x3f___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_LeanLibConfig_get___rarg___closed__1; +static lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2; +static lean_object* l_Lake_PackageFacetConfig_fetchJob___closed__2; +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_TargetDecl_fetch___rarg___closed__1; +lean_object* lean_string_append(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_LeanLib_fetchFacetJob(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +static lean_object* _init_l_Lake_Package_fetchTargetJob___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("package '", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchTargetJob___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' has no target '", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_fetchTargetJob___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("'", 1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchTargetJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; +x_9 = l_Lake_Package_findTargetConfig_x3f(x_2, x_1); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +x_10 = lean_ctor_get(x_1, 2); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_ctor_get(x_10, 2); +lean_inc(x_11); +lean_dec(x_10); +x_12 = 1; +x_13 = l_Lean_Name_toString(x_11, x_12); +x_14 = l_Lake_Package_fetchTargetJob___closed__1; +x_15 = lean_string_append(x_14, x_13); +lean_dec(x_13); +x_16 = l_Lake_Package_fetchTargetJob___closed__2; +x_17 = lean_string_append(x_15, x_16); +x_18 = l_Lean_Name_toString(x_2, x_12); +x_19 = lean_string_append(x_17, x_18); +lean_dec(x_18); +x_20 = l_Lake_Package_fetchTargetJob___closed__3; +x_21 = lean_string_append(x_19, x_20); +x_22 = 3; +x_23 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set_uint8(x_23, sizeof(void*)*1, x_22); +x_24 = lean_array_get_size(x_6); +x_25 = lean_array_push(x_6, x_23); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_7); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_8); +return x_28; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_9, 0); +lean_inc(x_29); +lean_dec(x_9); +x_30 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_30, 0, x_1); +lean_ctor_set(x_30, 1, x_2); +x_31 = lean_apply_6(x_3, x_30, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_31) == 0) +{ +lean_object* x_32; lean_object* x_33; +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_32, 0); +lean_inc(x_33); +if (lean_obj_tag(x_33) == 0) +{ +uint8_t x_34; +x_34 = !lean_is_exclusive(x_31); +if (x_34 == 0) +{ +lean_object* x_35; uint8_t x_36; +x_35 = lean_ctor_get(x_31, 0); +lean_dec(x_35); +x_36 = !lean_is_exclusive(x_32); +if (x_36 == 0) +{ +lean_object* x_37; uint8_t x_38; +x_37 = lean_ctor_get(x_32, 0); +lean_dec(x_37); +x_38 = !lean_is_exclusive(x_33); +if (x_38 == 0) +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_39 = lean_ctor_get(x_33, 0); +x_40 = lean_ctor_get(x_29, 1); +lean_inc(x_40); +lean_dec(x_29); +x_41 = lean_apply_1(x_40, x_39); +lean_ctor_set(x_33, 0, x_41); +return x_31; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_42 = lean_ctor_get(x_33, 0); +x_43 = lean_ctor_get(x_33, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_33); +x_44 = lean_ctor_get(x_29, 1); +lean_inc(x_44); +lean_dec(x_29); +x_45 = lean_apply_1(x_44, x_42); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_43); +lean_ctor_set(x_32, 0, x_46); +return x_31; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_47 = lean_ctor_get(x_32, 1); +lean_inc(x_47); +lean_dec(x_32); +x_48 = lean_ctor_get(x_33, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_33, 1); +lean_inc(x_49); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_50 = x_33; +} else { + lean_dec_ref(x_33); + x_50 = lean_box(0); +} +x_51 = lean_ctor_get(x_29, 1); +lean_inc(x_51); +lean_dec(x_29); +x_52 = lean_apply_1(x_51, x_48); +if (lean_is_scalar(x_50)) { + x_53 = lean_alloc_ctor(0, 2, 0); +} else { + x_53 = x_50; +} +lean_ctor_set(x_53, 0, x_52); +lean_ctor_set(x_53, 1, x_49); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_47); +lean_ctor_set(x_31, 0, x_54); +return x_31; +} +} +else +{ +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_55 = lean_ctor_get(x_31, 1); +lean_inc(x_55); +lean_dec(x_31); +x_56 = lean_ctor_get(x_32, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_57 = x_32; +} else { + lean_dec_ref(x_32); + x_57 = lean_box(0); +} +x_58 = lean_ctor_get(x_33, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_33, 1); +lean_inc(x_59); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_60 = x_33; +} else { + lean_dec_ref(x_33); + x_60 = lean_box(0); +} +x_61 = lean_ctor_get(x_29, 1); +lean_inc(x_61); +lean_dec(x_29); +x_62 = lean_apply_1(x_61, x_58); +if (lean_is_scalar(x_60)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_60; +} +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_59); +if (lean_is_scalar(x_57)) { + x_64 = lean_alloc_ctor(0, 2, 0); +} else { + x_64 = x_57; +} +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_56); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_55); +return x_65; +} +} +else +{ +uint8_t x_66; +lean_dec(x_29); +x_66 = !lean_is_exclusive(x_31); +if (x_66 == 0) +{ +lean_object* x_67; uint8_t x_68; +x_67 = lean_ctor_get(x_31, 0); +lean_dec(x_67); +x_68 = !lean_is_exclusive(x_32); +if (x_68 == 0) +{ +lean_object* x_69; uint8_t x_70; +x_69 = lean_ctor_get(x_32, 0); +lean_dec(x_69); +x_70 = !lean_is_exclusive(x_33); +if (x_70 == 0) +{ +return x_31; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_71 = lean_ctor_get(x_33, 0); +x_72 = lean_ctor_get(x_33, 1); +lean_inc(x_72); +lean_inc(x_71); +lean_dec(x_33); +x_73 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_73, 0, x_71); +lean_ctor_set(x_73, 1, x_72); +lean_ctor_set(x_32, 0, x_73); +return x_31; +} +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_74 = lean_ctor_get(x_32, 1); +lean_inc(x_74); +lean_dec(x_32); +x_75 = lean_ctor_get(x_33, 0); +lean_inc(x_75); +x_76 = lean_ctor_get(x_33, 1); +lean_inc(x_76); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_77 = x_33; +} else { + lean_dec_ref(x_33); + x_77 = lean_box(0); +} +if (lean_is_scalar(x_77)) { + x_78 = lean_alloc_ctor(1, 2, 0); +} else { + x_78 = x_77; +} +lean_ctor_set(x_78, 0, x_75); +lean_ctor_set(x_78, 1, x_76); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_74); +lean_ctor_set(x_31, 0, x_79); +return x_31; +} +} +else +{ +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_80 = lean_ctor_get(x_31, 1); +lean_inc(x_80); +lean_dec(x_31); +x_81 = lean_ctor_get(x_32, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_82 = x_32; +} else { + lean_dec_ref(x_32); + x_82 = lean_box(0); +} +x_83 = lean_ctor_get(x_33, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_33, 1); +lean_inc(x_84); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_85 = x_33; +} else { + lean_dec_ref(x_33); + x_85 = lean_box(0); +} +if (lean_is_scalar(x_85)) { + x_86 = lean_alloc_ctor(1, 2, 0); +} else { + x_86 = x_85; +} +lean_ctor_set(x_86, 0, x_83); +lean_ctor_set(x_86, 1, x_84); +if (lean_is_scalar(x_82)) { + x_87 = lean_alloc_ctor(0, 2, 0); +} else { + x_87 = x_82; +} +lean_ctor_set(x_87, 0, x_86); +lean_ctor_set(x_87, 1, x_81); +x_88 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_80); +return x_88; +} +} +} +else +{ +uint8_t x_89; +lean_dec(x_29); +x_89 = !lean_is_exclusive(x_31); +if (x_89 == 0) +{ +return x_31; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_31, 0); +x_91 = lean_ctor_get(x_31, 1); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_31); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set(x_92, 1, x_91); +return x_92; +} +} +} +} +} +static lean_object* _init_l_Lake_TargetDecl_fetch___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' of target '", 13); +return x_1; +} +} +static lean_object* _init_l_Lake_TargetDecl_fetch___rarg___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' does not exist in workspace", 29); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_TargetDecl_fetch___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_9 = lean_ctor_get(x_1, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_1, 1); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_ctor_get(x_5, 1); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 3); +lean_inc(x_12); +lean_dec(x_11); +x_13 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(x_12, x_9); +lean_dec(x_12); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +x_14 = 1; +x_15 = l_Lean_Name_toString(x_9, x_14); +x_16 = l_Lake_Package_fetchTargetJob___closed__1; +x_17 = lean_string_append(x_16, x_15); +lean_dec(x_15); +x_18 = l_Lake_TargetDecl_fetch___rarg___closed__1; +x_19 = lean_string_append(x_17, x_18); +x_20 = l_Lean_Name_toString(x_10, x_14); +x_21 = lean_string_append(x_19, x_20); +lean_dec(x_20); +x_22 = l_Lake_TargetDecl_fetch___rarg___closed__2; +x_23 = lean_string_append(x_21, x_22); +x_24 = 3; +x_25 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set_uint8(x_25, sizeof(void*)*1, x_24); +x_26 = lean_array_get_size(x_6); +x_27 = lean_array_push(x_6, x_25); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_7); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_8); +return x_30; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_9); +x_31 = lean_ctor_get(x_13, 0); +lean_inc(x_31); +lean_dec(x_13); +x_32 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_10); +x_33 = lean_apply_6(x_3, x_32, x_4, x_5, x_6, x_7, x_8); +return x_33; +} +} +} +LEAN_EXPORT lean_object* l_Lake_TargetDecl_fetch(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_TargetDecl_fetch___rarg), 8, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_TargetDecl_fetchJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_1, 2); +lean_inc(x_10); +lean_dec(x_1); +x_11 = lean_ctor_get(x_4, 1); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 3); +lean_inc(x_12); +lean_dec(x_11); +x_13 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(x_12, x_8); +lean_dec(x_12); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_dec(x_10); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_14 = 1; +x_15 = l_Lean_Name_toString(x_8, x_14); +x_16 = l_Lake_Package_fetchTargetJob___closed__1; +x_17 = lean_string_append(x_16, x_15); +lean_dec(x_15); +x_18 = l_Lake_TargetDecl_fetch___rarg___closed__1; +x_19 = lean_string_append(x_17, x_18); +x_20 = l_Lean_Name_toString(x_9, x_14); +x_21 = lean_string_append(x_19, x_20); +lean_dec(x_20); +x_22 = l_Lake_TargetDecl_fetch___rarg___closed__2; +x_23 = lean_string_append(x_21, x_22); +x_24 = 3; +x_25 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set_uint8(x_25, sizeof(void*)*1, x_24); +x_26 = lean_array_get_size(x_5); +x_27 = lean_array_push(x_5, x_25); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_6); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_7); +return x_30; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; +lean_dec(x_8); +x_31 = lean_ctor_get(x_13, 0); +lean_inc(x_31); +lean_dec(x_13); +x_32 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_9); +x_33 = lean_apply_6(x_2, x_32, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; lean_object* x_35; +x_34 = lean_ctor_get(x_33, 0); +lean_inc(x_34); +x_35 = lean_ctor_get(x_34, 0); +lean_inc(x_35); +if (lean_obj_tag(x_35) == 0) +{ +uint8_t x_36; +x_36 = !lean_is_exclusive(x_33); +if (x_36 == 0) +{ +lean_object* x_37; uint8_t x_38; +x_37 = lean_ctor_get(x_33, 0); +lean_dec(x_37); +x_38 = !lean_is_exclusive(x_34); +if (x_38 == 0) +{ +lean_object* x_39; uint8_t x_40; +x_39 = lean_ctor_get(x_34, 0); +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_35); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_35, 0); +x_42 = lean_ctor_get(x_10, 1); +lean_inc(x_42); +lean_dec(x_10); +x_43 = lean_apply_1(x_42, x_41); +lean_ctor_set(x_35, 0, x_43); +return x_33; +} +else +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_44 = lean_ctor_get(x_35, 0); +x_45 = lean_ctor_get(x_35, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_35); +x_46 = lean_ctor_get(x_10, 1); +lean_inc(x_46); +lean_dec(x_10); +x_47 = lean_apply_1(x_46, x_44); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_47); +lean_ctor_set(x_48, 1, x_45); +lean_ctor_set(x_34, 0, x_48); +return x_33; +} +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_49 = lean_ctor_get(x_34, 1); +lean_inc(x_49); +lean_dec(x_34); +x_50 = lean_ctor_get(x_35, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_35, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_52 = x_35; +} else { + lean_dec_ref(x_35); + x_52 = lean_box(0); +} +x_53 = lean_ctor_get(x_10, 1); +lean_inc(x_53); +lean_dec(x_10); +x_54 = lean_apply_1(x_53, x_50); +if (lean_is_scalar(x_52)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_52; +} +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_51); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +lean_ctor_set(x_33, 0, x_56); +return x_33; +} +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_57 = lean_ctor_get(x_33, 1); +lean_inc(x_57); +lean_dec(x_33); +x_58 = lean_ctor_get(x_34, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_34)) { + lean_ctor_release(x_34, 0); + lean_ctor_release(x_34, 1); + x_59 = x_34; +} else { + lean_dec_ref(x_34); + x_59 = lean_box(0); +} +x_60 = lean_ctor_get(x_35, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_35, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_62 = x_35; +} else { + lean_dec_ref(x_35); + x_62 = lean_box(0); +} +x_63 = lean_ctor_get(x_10, 1); +lean_inc(x_63); +lean_dec(x_10); +x_64 = lean_apply_1(x_63, x_60); +if (lean_is_scalar(x_62)) { + x_65 = lean_alloc_ctor(0, 2, 0); +} else { + x_65 = x_62; +} +lean_ctor_set(x_65, 0, x_64); +lean_ctor_set(x_65, 1, x_61); +if (lean_is_scalar(x_59)) { + x_66 = lean_alloc_ctor(0, 2, 0); +} else { + x_66 = x_59; +} +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_58); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_66); +lean_ctor_set(x_67, 1, x_57); +return x_67; +} +} +else +{ +uint8_t x_68; +lean_dec(x_10); +x_68 = !lean_is_exclusive(x_33); +if (x_68 == 0) +{ +lean_object* x_69; uint8_t x_70; +x_69 = lean_ctor_get(x_33, 0); +lean_dec(x_69); +x_70 = !lean_is_exclusive(x_34); +if (x_70 == 0) +{ +lean_object* x_71; uint8_t x_72; +x_71 = lean_ctor_get(x_34, 0); +lean_dec(x_71); +x_72 = !lean_is_exclusive(x_35); +if (x_72 == 0) +{ +return x_33; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_73 = lean_ctor_get(x_35, 0); +x_74 = lean_ctor_get(x_35, 1); +lean_inc(x_74); +lean_inc(x_73); +lean_dec(x_35); +x_75 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_75, 0, x_73); +lean_ctor_set(x_75, 1, x_74); +lean_ctor_set(x_34, 0, x_75); +return x_33; +} +} +else +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_76 = lean_ctor_get(x_34, 1); +lean_inc(x_76); +lean_dec(x_34); +x_77 = lean_ctor_get(x_35, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_35, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_79 = x_35; +} else { + lean_dec_ref(x_35); + x_79 = lean_box(0); +} +if (lean_is_scalar(x_79)) { + x_80 = lean_alloc_ctor(1, 2, 0); +} else { + x_80 = x_79; +} +lean_ctor_set(x_80, 0, x_77); +lean_ctor_set(x_80, 1, x_78); +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_76); +lean_ctor_set(x_33, 0, x_81); +return x_33; +} +} +else +{ +lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; +x_82 = lean_ctor_get(x_33, 1); +lean_inc(x_82); +lean_dec(x_33); +x_83 = lean_ctor_get(x_34, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_34)) { + lean_ctor_release(x_34, 0); + lean_ctor_release(x_34, 1); + x_84 = x_34; +} else { + lean_dec_ref(x_34); + x_84 = lean_box(0); +} +x_85 = lean_ctor_get(x_35, 0); +lean_inc(x_85); +x_86 = lean_ctor_get(x_35, 1); +lean_inc(x_86); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_87 = x_35; +} else { + lean_dec_ref(x_35); + x_87 = lean_box(0); +} +if (lean_is_scalar(x_87)) { + x_88 = lean_alloc_ctor(1, 2, 0); +} else { + x_88 = x_87; +} +lean_ctor_set(x_88, 0, x_85); +lean_ctor_set(x_88, 1, x_86); +if (lean_is_scalar(x_84)) { + x_89 = lean_alloc_ctor(0, 2, 0); +} else { + x_89 = x_84; +} +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_83); +x_90 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_90, 0, x_89); +lean_ctor_set(x_90, 1, x_82); +return x_90; +} +} +} +else +{ +uint8_t x_91; +lean_dec(x_10); +x_91 = !lean_is_exclusive(x_33); +if (x_91 == 0) +{ +return x_33; +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_92 = lean_ctor_get(x_33, 0); +x_93 = lean_ctor_get(x_33, 1); +lean_inc(x_93); +lean_inc(x_92); +lean_dec(x_33); +x_94 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_94, 0, x_92); +lean_ctor_set(x_94, 1, x_93); +return x_94; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_PackageFacetDecl_fetch___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_2, 0); +lean_inc(x_10); +x_11 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_11, 0, x_1); +lean_ctor_set(x_11, 1, x_10); +x_12 = lean_apply_6(x_4, x_11, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_PackageFacetDecl_fetch(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_PackageFacetDecl_fetch___rarg___boxed), 9, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_PackageFacetDecl_fetch___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_PackageFacetDecl_fetch___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_2); +return x_10; +} +} +static lean_object* _init_l_Lake_PackageFacetConfig_fetchJob___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("package facet '", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_PackageFacetConfig_fetchJob___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' has no associated build job", 29); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_PackageFacetConfig_fetchJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_3, 1); +lean_inc(x_10); +lean_dec(x_3); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_11 = 1; +x_12 = l_Lean_Name_toString(x_1, x_11); +x_13 = l_Lake_PackageFacetConfig_fetchJob___closed__1; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lake_PackageFacetConfig_fetchJob___closed__2; +x_16 = lean_string_append(x_14, x_15); +x_17 = 3; +x_18 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set_uint8(x_18, sizeof(void*)*1, x_17); +x_19 = lean_array_get_size(x_7); +x_20 = lean_array_push(x_7, x_18); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_8); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_9); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_10, 0); +lean_inc(x_24); +lean_dec(x_10); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_2); +lean_ctor_set(x_25, 1, x_1); +x_26 = lean_apply_6(x_4, x_25, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_26) == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_26, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +if (lean_obj_tag(x_28) == 0) +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_26); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_26, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_27); +if (x_31 == 0) +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_27, 0); +lean_dec(x_32); +x_33 = !lean_is_exclusive(x_28); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; +x_34 = lean_ctor_get(x_28, 0); +x_35 = lean_apply_1(x_24, x_34); +lean_ctor_set(x_28, 0, x_35); +return x_26; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = lean_ctor_get(x_28, 0); +x_37 = lean_ctor_get(x_28, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_28); +x_38 = lean_apply_1(x_24, x_36); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_37); +lean_ctor_set(x_27, 0, x_39); +return x_26; +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_40 = lean_ctor_get(x_27, 1); +lean_inc(x_40); +lean_dec(x_27); +x_41 = lean_ctor_get(x_28, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_28, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_43 = x_28; +} else { + lean_dec_ref(x_28); + x_43 = lean_box(0); +} +x_44 = lean_apply_1(x_24, x_41); +if (lean_is_scalar(x_43)) { + x_45 = lean_alloc_ctor(0, 2, 0); +} else { + x_45 = x_43; +} +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_42); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_40); +lean_ctor_set(x_26, 0, x_46); +return x_26; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_47 = lean_ctor_get(x_26, 1); +lean_inc(x_47); +lean_dec(x_26); +x_48 = lean_ctor_get(x_27, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_49 = x_27; +} else { + lean_dec_ref(x_27); + x_49 = lean_box(0); +} +x_50 = lean_ctor_get(x_28, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_28, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_52 = x_28; +} else { + lean_dec_ref(x_28); + x_52 = lean_box(0); +} +x_53 = lean_apply_1(x_24, x_50); +if (lean_is_scalar(x_52)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_52; +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_51); +if (lean_is_scalar(x_49)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_49; +} +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_48); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_47); +return x_56; +} +} +else +{ +uint8_t x_57; +lean_dec(x_24); +x_57 = !lean_is_exclusive(x_26); +if (x_57 == 0) +{ +lean_object* x_58; uint8_t x_59; +x_58 = lean_ctor_get(x_26, 0); +lean_dec(x_58); +x_59 = !lean_is_exclusive(x_27); +if (x_59 == 0) +{ +lean_object* x_60; uint8_t x_61; +x_60 = lean_ctor_get(x_27, 0); +lean_dec(x_60); +x_61 = !lean_is_exclusive(x_28); +if (x_61 == 0) +{ +return x_26; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_62 = lean_ctor_get(x_28, 0); +x_63 = lean_ctor_get(x_28, 1); +lean_inc(x_63); +lean_inc(x_62); +lean_dec(x_28); +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set(x_64, 1, x_63); +lean_ctor_set(x_27, 0, x_64); +return x_26; +} +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_65 = lean_ctor_get(x_27, 1); +lean_inc(x_65); +lean_dec(x_27); +x_66 = lean_ctor_get(x_28, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_28, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_68 = x_28; +} else { + lean_dec_ref(x_28); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_65); +lean_ctor_set(x_26, 0, x_70); +return x_26; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_71 = lean_ctor_get(x_26, 1); +lean_inc(x_71); +lean_dec(x_26); +x_72 = lean_ctor_get(x_27, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_73 = x_27; +} else { + lean_dec_ref(x_27); + x_73 = lean_box(0); +} +x_74 = lean_ctor_get(x_28, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_28, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_76 = x_28; +} else { + lean_dec_ref(x_28); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_76)) { + x_77 = lean_alloc_ctor(1, 2, 0); +} else { + x_77 = x_76; +} +lean_ctor_set(x_77, 0, x_74); +lean_ctor_set(x_77, 1, x_75); +if (lean_is_scalar(x_73)) { + x_78 = lean_alloc_ctor(0, 2, 0); +} else { + x_78 = x_73; +} +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_72); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_71); +return x_79; +} +} +} +else +{ +uint8_t x_80; +lean_dec(x_24); +x_80 = !lean_is_exclusive(x_26); +if (x_80 == 0) +{ +return x_26; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_81 = lean_ctor_get(x_26, 0); +x_82 = lean_ctor_get(x_26, 1); +lean_inc(x_82); +lean_inc(x_81); +lean_dec(x_26); +x_83 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_83, 0, x_81); +lean_ctor_set(x_83, 1, x_82); +return x_83; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_fetchFacetJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_5, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_9, 5); +lean_inc(x_10); +lean_dec(x_9); +x_11 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackageFacetConfig_x3f___spec__1(x_10, x_1); +lean_dec(x_10); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_12 = 1; +x_13 = l_Lean_Name_toString(x_1, x_12); +x_14 = l_Lake_PackageFacetConfig_fetchJob___closed__1; +x_15 = lean_string_append(x_14, x_13); +lean_dec(x_13); +x_16 = l_Lake_TargetDecl_fetch___rarg___closed__2; +x_17 = lean_string_append(x_15, x_16); +x_18 = 3; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = lean_array_get_size(x_6); +x_21 = lean_array_push(x_6, x_19); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_7); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_8); +return x_24; +} +else +{ +lean_object* x_25; lean_object* x_26; +x_25 = lean_ctor_get(x_11, 0); +lean_inc(x_25); +lean_dec(x_11); +x_26 = lean_ctor_get(x_25, 1); +lean_inc(x_26); +lean_dec(x_25); +if (lean_obj_tag(x_26) == 0) +{ +uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_27 = 1; +x_28 = l_Lean_Name_toString(x_1, x_27); +x_29 = l_Lake_PackageFacetConfig_fetchJob___closed__1; +x_30 = lean_string_append(x_29, x_28); +lean_dec(x_28); +x_31 = l_Lake_PackageFacetConfig_fetchJob___closed__2; +x_32 = lean_string_append(x_30, x_31); +x_33 = 3; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = lean_array_get_size(x_6); +x_36 = lean_array_push(x_6, x_34); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_7); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_8); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_26, 0); +lean_inc(x_40); +lean_dec(x_26); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_2); +lean_ctor_set(x_41, 1, x_1); +x_42 = lean_apply_6(x_3, x_41, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +if (lean_obj_tag(x_44) == 0) +{ +uint8_t x_45; +x_45 = !lean_is_exclusive(x_42); +if (x_45 == 0) +{ +lean_object* x_46; uint8_t x_47; +x_46 = lean_ctor_get(x_42, 0); +lean_dec(x_46); +x_47 = !lean_is_exclusive(x_43); +if (x_47 == 0) +{ +lean_object* x_48; uint8_t x_49; +x_48 = lean_ctor_get(x_43, 0); +lean_dec(x_48); +x_49 = !lean_is_exclusive(x_44); +if (x_49 == 0) +{ +lean_object* x_50; lean_object* x_51; +x_50 = lean_ctor_get(x_44, 0); +x_51 = lean_apply_1(x_40, x_50); +lean_ctor_set(x_44, 0, x_51); +return x_42; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_44, 0); +x_53 = lean_ctor_get(x_44, 1); +lean_inc(x_53); +lean_inc(x_52); +lean_dec(x_44); +x_54 = lean_apply_1(x_40, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_53); +lean_ctor_set(x_43, 0, x_55); +return x_42; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_56 = lean_ctor_get(x_43, 1); +lean_inc(x_56); +lean_dec(x_43); +x_57 = lean_ctor_get(x_44, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_44, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_59 = x_44; +} else { + lean_dec_ref(x_44); + x_59 = lean_box(0); +} +x_60 = lean_apply_1(x_40, x_57); +if (lean_is_scalar(x_59)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_59; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_58); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_56); +lean_ctor_set(x_42, 0, x_62); +return x_42; +} +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_63 = lean_ctor_get(x_42, 1); +lean_inc(x_63); +lean_dec(x_42); +x_64 = lean_ctor_get(x_43, 1); +lean_inc(x_64); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_65 = x_43; +} else { + lean_dec_ref(x_43); + x_65 = lean_box(0); +} +x_66 = lean_ctor_get(x_44, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_44, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_68 = x_44; +} else { + lean_dec_ref(x_44); + x_68 = lean_box(0); +} +x_69 = lean_apply_1(x_40, x_66); +if (lean_is_scalar(x_68)) { + x_70 = lean_alloc_ctor(0, 2, 0); +} else { + x_70 = x_68; +} +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +if (lean_is_scalar(x_65)) { + x_71 = lean_alloc_ctor(0, 2, 0); +} else { + x_71 = x_65; +} +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_64); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_63); +return x_72; +} +} +else +{ +uint8_t x_73; +lean_dec(x_40); +x_73 = !lean_is_exclusive(x_42); +if (x_73 == 0) +{ +lean_object* x_74; uint8_t x_75; +x_74 = lean_ctor_get(x_42, 0); +lean_dec(x_74); +x_75 = !lean_is_exclusive(x_43); +if (x_75 == 0) +{ +lean_object* x_76; uint8_t x_77; +x_76 = lean_ctor_get(x_43, 0); +lean_dec(x_76); +x_77 = !lean_is_exclusive(x_44); +if (x_77 == 0) +{ +return x_42; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_78 = lean_ctor_get(x_44, 0); +x_79 = lean_ctor_get(x_44, 1); +lean_inc(x_79); +lean_inc(x_78); +lean_dec(x_44); +x_80 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set(x_80, 1, x_79); +lean_ctor_set(x_43, 0, x_80); +return x_42; +} +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_81 = lean_ctor_get(x_43, 1); +lean_inc(x_81); +lean_dec(x_43); +x_82 = lean_ctor_get(x_44, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_44, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_84 = x_44; +} else { + lean_dec_ref(x_44); + x_84 = lean_box(0); +} +if (lean_is_scalar(x_84)) { + x_85 = lean_alloc_ctor(1, 2, 0); +} else { + x_85 = x_84; +} +lean_ctor_set(x_85, 0, x_82); +lean_ctor_set(x_85, 1, x_83); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_81); +lean_ctor_set(x_42, 0, x_86); +return x_42; +} +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_87 = lean_ctor_get(x_42, 1); +lean_inc(x_87); +lean_dec(x_42); +x_88 = lean_ctor_get(x_43, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_89 = x_43; +} else { + lean_dec_ref(x_43); + x_89 = lean_box(0); +} +x_90 = lean_ctor_get(x_44, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_44, 1); +lean_inc(x_91); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_92 = x_44; +} else { + lean_dec_ref(x_44); + x_92 = lean_box(0); +} +if (lean_is_scalar(x_92)) { + x_93 = lean_alloc_ctor(1, 2, 0); +} else { + x_93 = x_92; +} +lean_ctor_set(x_93, 0, x_90); +lean_ctor_set(x_93, 1, x_91); +if (lean_is_scalar(x_89)) { + x_94 = lean_alloc_ctor(0, 2, 0); +} else { + x_94 = x_89; +} +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_88); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_87); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_40); +x_96 = !lean_is_exclusive(x_42); +if (x_96 == 0) +{ +return x_42; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_97 = lean_ctor_get(x_42, 0); +x_98 = lean_ctor_get(x_42, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_42); +x_99 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set(x_99, 1, x_98); +return x_99; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_ModuleFacetDecl_fetch___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_2, 0); +lean_inc(x_10); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_1); +lean_ctor_set(x_11, 1, x_10); +x_12 = lean_apply_6(x_4, x_11, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_ModuleFacetDecl_fetch(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_ModuleFacetDecl_fetch___rarg___boxed), 9, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_ModuleFacetDecl_fetch___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_ModuleFacetDecl_fetch___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_2); +return x_10; +} +} +static lean_object* _init_l_Lake_ModuleFacetConfig_fetchJob___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("module facet '", 14); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_ModuleFacetConfig_fetchJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_3, 1); +lean_inc(x_10); +lean_dec(x_3); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_11 = 1; +x_12 = l_Lean_Name_toString(x_1, x_11); +x_13 = l_Lake_ModuleFacetConfig_fetchJob___closed__1; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lake_PackageFacetConfig_fetchJob___closed__2; +x_16 = lean_string_append(x_14, x_15); +x_17 = 3; +x_18 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set_uint8(x_18, sizeof(void*)*1, x_17); +x_19 = lean_array_get_size(x_7); +x_20 = lean_array_push(x_7, x_18); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_8); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_9); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_10, 0); +lean_inc(x_24); +lean_dec(x_10); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_2); +lean_ctor_set(x_25, 1, x_1); +x_26 = lean_apply_6(x_4, x_25, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_26) == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_26, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +if (lean_obj_tag(x_28) == 0) +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_26); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_26, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_27); +if (x_31 == 0) +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_27, 0); +lean_dec(x_32); +x_33 = !lean_is_exclusive(x_28); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; +x_34 = lean_ctor_get(x_28, 0); +x_35 = lean_apply_1(x_24, x_34); +lean_ctor_set(x_28, 0, x_35); +return x_26; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = lean_ctor_get(x_28, 0); +x_37 = lean_ctor_get(x_28, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_28); +x_38 = lean_apply_1(x_24, x_36); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_37); +lean_ctor_set(x_27, 0, x_39); +return x_26; +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_40 = lean_ctor_get(x_27, 1); +lean_inc(x_40); +lean_dec(x_27); +x_41 = lean_ctor_get(x_28, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_28, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_43 = x_28; +} else { + lean_dec_ref(x_28); + x_43 = lean_box(0); +} +x_44 = lean_apply_1(x_24, x_41); +if (lean_is_scalar(x_43)) { + x_45 = lean_alloc_ctor(0, 2, 0); +} else { + x_45 = x_43; +} +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_42); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_40); +lean_ctor_set(x_26, 0, x_46); +return x_26; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_47 = lean_ctor_get(x_26, 1); +lean_inc(x_47); +lean_dec(x_26); +x_48 = lean_ctor_get(x_27, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_49 = x_27; +} else { + lean_dec_ref(x_27); + x_49 = lean_box(0); +} +x_50 = lean_ctor_get(x_28, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_28, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_52 = x_28; +} else { + lean_dec_ref(x_28); + x_52 = lean_box(0); +} +x_53 = lean_apply_1(x_24, x_50); +if (lean_is_scalar(x_52)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_52; +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_51); +if (lean_is_scalar(x_49)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_49; +} +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_48); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_47); +return x_56; +} +} +else +{ +uint8_t x_57; +lean_dec(x_24); +x_57 = !lean_is_exclusive(x_26); +if (x_57 == 0) +{ +lean_object* x_58; uint8_t x_59; +x_58 = lean_ctor_get(x_26, 0); +lean_dec(x_58); +x_59 = !lean_is_exclusive(x_27); +if (x_59 == 0) +{ +lean_object* x_60; uint8_t x_61; +x_60 = lean_ctor_get(x_27, 0); +lean_dec(x_60); +x_61 = !lean_is_exclusive(x_28); +if (x_61 == 0) +{ +return x_26; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_62 = lean_ctor_get(x_28, 0); +x_63 = lean_ctor_get(x_28, 1); +lean_inc(x_63); +lean_inc(x_62); +lean_dec(x_28); +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set(x_64, 1, x_63); +lean_ctor_set(x_27, 0, x_64); +return x_26; +} +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_65 = lean_ctor_get(x_27, 1); +lean_inc(x_65); +lean_dec(x_27); +x_66 = lean_ctor_get(x_28, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_28, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_68 = x_28; +} else { + lean_dec_ref(x_28); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_65); +lean_ctor_set(x_26, 0, x_70); +return x_26; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_71 = lean_ctor_get(x_26, 1); +lean_inc(x_71); +lean_dec(x_26); +x_72 = lean_ctor_get(x_27, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_73 = x_27; +} else { + lean_dec_ref(x_27); + x_73 = lean_box(0); +} +x_74 = lean_ctor_get(x_28, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_28, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_76 = x_28; +} else { + lean_dec_ref(x_28); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_76)) { + x_77 = lean_alloc_ctor(1, 2, 0); +} else { + x_77 = x_76; +} +lean_ctor_set(x_77, 0, x_74); +lean_ctor_set(x_77, 1, x_75); +if (lean_is_scalar(x_73)) { + x_78 = lean_alloc_ctor(0, 2, 0); +} else { + x_78 = x_73; +} +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_72); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_71); +return x_79; +} +} +} +else +{ +uint8_t x_80; +lean_dec(x_24); +x_80 = !lean_is_exclusive(x_26); +if (x_80 == 0) +{ +return x_26; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_81 = lean_ctor_get(x_26, 0); +x_82 = lean_ctor_get(x_26, 1); +lean_inc(x_82); +lean_inc(x_81); +lean_dec(x_26); +x_83 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_83, 0, x_81); +lean_ctor_set(x_83, 1, x_82); +return x_83; +} +} +} +} +} +static lean_object* _init_l_Lake_Module_fetchFacetJob___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("library facet '", 15); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Module_fetchFacetJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_5, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_9, 4); +lean_inc(x_10); +lean_dec(x_9); +x_11 = l_Lake_RBNode_dFind___at_Lake_Workspace_findModuleFacetConfig_x3f___spec__1(x_10, x_1); +lean_dec(x_10); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_12 = 1; +x_13 = l_Lean_Name_toString(x_1, x_12); +x_14 = l_Lake_Module_fetchFacetJob___closed__1; +x_15 = lean_string_append(x_14, x_13); +lean_dec(x_13); +x_16 = l_Lake_TargetDecl_fetch___rarg___closed__2; +x_17 = lean_string_append(x_15, x_16); +x_18 = 3; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = lean_array_get_size(x_6); +x_21 = lean_array_push(x_6, x_19); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_7); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_8); +return x_24; +} +else +{ +lean_object* x_25; lean_object* x_26; +x_25 = lean_ctor_get(x_11, 0); +lean_inc(x_25); +lean_dec(x_11); +x_26 = lean_ctor_get(x_25, 1); +lean_inc(x_26); +lean_dec(x_25); +if (lean_obj_tag(x_26) == 0) +{ +uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_27 = 1; +x_28 = l_Lean_Name_toString(x_1, x_27); +x_29 = l_Lake_ModuleFacetConfig_fetchJob___closed__1; +x_30 = lean_string_append(x_29, x_28); +lean_dec(x_28); +x_31 = l_Lake_PackageFacetConfig_fetchJob___closed__2; +x_32 = lean_string_append(x_30, x_31); +x_33 = 3; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = lean_array_get_size(x_6); +x_36 = lean_array_push(x_6, x_34); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_7); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_8); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_26, 0); +lean_inc(x_40); +lean_dec(x_26); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_2); +lean_ctor_set(x_41, 1, x_1); +x_42 = lean_apply_6(x_3, x_41, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +if (lean_obj_tag(x_44) == 0) +{ +uint8_t x_45; +x_45 = !lean_is_exclusive(x_42); +if (x_45 == 0) +{ +lean_object* x_46; uint8_t x_47; +x_46 = lean_ctor_get(x_42, 0); +lean_dec(x_46); +x_47 = !lean_is_exclusive(x_43); +if (x_47 == 0) +{ +lean_object* x_48; uint8_t x_49; +x_48 = lean_ctor_get(x_43, 0); +lean_dec(x_48); +x_49 = !lean_is_exclusive(x_44); +if (x_49 == 0) +{ +lean_object* x_50; lean_object* x_51; +x_50 = lean_ctor_get(x_44, 0); +x_51 = lean_apply_1(x_40, x_50); +lean_ctor_set(x_44, 0, x_51); +return x_42; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_44, 0); +x_53 = lean_ctor_get(x_44, 1); +lean_inc(x_53); +lean_inc(x_52); +lean_dec(x_44); +x_54 = lean_apply_1(x_40, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_53); +lean_ctor_set(x_43, 0, x_55); +return x_42; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_56 = lean_ctor_get(x_43, 1); +lean_inc(x_56); +lean_dec(x_43); +x_57 = lean_ctor_get(x_44, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_44, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_59 = x_44; +} else { + lean_dec_ref(x_44); + x_59 = lean_box(0); +} +x_60 = lean_apply_1(x_40, x_57); +if (lean_is_scalar(x_59)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_59; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_58); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_56); +lean_ctor_set(x_42, 0, x_62); +return x_42; +} +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_63 = lean_ctor_get(x_42, 1); +lean_inc(x_63); +lean_dec(x_42); +x_64 = lean_ctor_get(x_43, 1); +lean_inc(x_64); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_65 = x_43; +} else { + lean_dec_ref(x_43); + x_65 = lean_box(0); +} +x_66 = lean_ctor_get(x_44, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_44, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_68 = x_44; +} else { + lean_dec_ref(x_44); + x_68 = lean_box(0); +} +x_69 = lean_apply_1(x_40, x_66); +if (lean_is_scalar(x_68)) { + x_70 = lean_alloc_ctor(0, 2, 0); +} else { + x_70 = x_68; +} +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +if (lean_is_scalar(x_65)) { + x_71 = lean_alloc_ctor(0, 2, 0); +} else { + x_71 = x_65; +} +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_64); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_63); +return x_72; +} +} +else +{ +uint8_t x_73; +lean_dec(x_40); +x_73 = !lean_is_exclusive(x_42); +if (x_73 == 0) +{ +lean_object* x_74; uint8_t x_75; +x_74 = lean_ctor_get(x_42, 0); +lean_dec(x_74); +x_75 = !lean_is_exclusive(x_43); +if (x_75 == 0) +{ +lean_object* x_76; uint8_t x_77; +x_76 = lean_ctor_get(x_43, 0); +lean_dec(x_76); +x_77 = !lean_is_exclusive(x_44); +if (x_77 == 0) +{ +return x_42; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_78 = lean_ctor_get(x_44, 0); +x_79 = lean_ctor_get(x_44, 1); +lean_inc(x_79); +lean_inc(x_78); +lean_dec(x_44); +x_80 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set(x_80, 1, x_79); +lean_ctor_set(x_43, 0, x_80); +return x_42; +} +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_81 = lean_ctor_get(x_43, 1); +lean_inc(x_81); +lean_dec(x_43); +x_82 = lean_ctor_get(x_44, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_44, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_84 = x_44; +} else { + lean_dec_ref(x_44); + x_84 = lean_box(0); +} +if (lean_is_scalar(x_84)) { + x_85 = lean_alloc_ctor(1, 2, 0); +} else { + x_85 = x_84; +} +lean_ctor_set(x_85, 0, x_82); +lean_ctor_set(x_85, 1, x_83); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_81); +lean_ctor_set(x_42, 0, x_86); +return x_42; +} +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_87 = lean_ctor_get(x_42, 1); +lean_inc(x_87); +lean_dec(x_42); +x_88 = lean_ctor_get(x_43, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_89 = x_43; +} else { + lean_dec_ref(x_43); + x_89 = lean_box(0); +} +x_90 = lean_ctor_get(x_44, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_44, 1); +lean_inc(x_91); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_92 = x_44; +} else { + lean_dec_ref(x_44); + x_92 = lean_box(0); +} +if (lean_is_scalar(x_92)) { + x_93 = lean_alloc_ctor(1, 2, 0); +} else { + x_93 = x_92; +} +lean_ctor_set(x_93, 0, x_90); +lean_ctor_set(x_93, 1, x_91); +if (lean_is_scalar(x_89)) { + x_94 = lean_alloc_ctor(0, 2, 0); +} else { + x_94 = x_89; +} +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_88); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_87); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_40); +x_96 = !lean_is_exclusive(x_42); +if (x_96 == 0) +{ +return x_42; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_97 = lean_ctor_get(x_42, 0); +x_98 = lean_ctor_get(x_42, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_42); +x_99 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set(x_99, 1, x_98); +return x_99; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__1(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lean library '", 14); +return x_1; +} +} +static lean_object* _init_l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' does not exist in the workspace", 33); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_3); +x_5 = 1; +x_6 = l_Lean_Name_toString(x_1, x_5); +x_7 = l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__1; +x_8 = lean_string_append(x_7, x_6); +lean_dec(x_6); +x_9 = l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2; +x_10 = lean_string_append(x_8, x_9); +x_11 = lean_apply_2(x_2, lean_box(0), x_10); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_2); +lean_dec(x_1); +x_12 = lean_ctor_get(x_4, 0); +lean_inc(x_12); +lean_dec(x_4); +x_13 = lean_ctor_get(x_3, 1); +lean_inc(x_13); +lean_dec(x_3); +x_14 = lean_apply_2(x_13, lean_box(0), x_12); +return x_14; +} +} +} +static lean_object* _init_l_Lake_LeanLibConfig_get___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_LeanLibConfig_get___rarg___lambda__1___boxed), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +x_6 = lean_ctor_get(x_2, 0); +lean_inc(x_6); +lean_dec(x_2); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +lean_dec(x_1); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +lean_dec(x_7); +lean_inc(x_8); +x_10 = lean_alloc_closure((void*)(l_Lake_Workspace_findLeanLib_x3f___boxed), 2, 1); +lean_closure_set(x_10, 0, x_8); +x_11 = l_Lake_LeanLibConfig_get___rarg___closed__1; +lean_inc(x_9); +x_12 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_11, x_4); +x_13 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_10, x_12); +x_14 = lean_alloc_closure((void*)(l_Lake_LeanLibConfig_get___rarg___lambda__2), 4, 3); +lean_closure_set(x_14, 0, x_8); +lean_closure_set(x_14, 1, x_3); +lean_closure_set(x_14, 2, x_6); +x_15 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_13, x_14); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_LeanLibConfig_get___rarg), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLibConfig_get___rarg___lambda__1___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_LeanLibConfig_get___rarg___lambda__1(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_LibraryFacetDecl_fetch___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_2, 0); +lean_inc(x_10); +x_11 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_11, 0, x_1); +lean_ctor_set(x_11, 1, x_10); +x_12 = lean_apply_6(x_4, x_11, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_LibraryFacetDecl_fetch(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_LibraryFacetDecl_fetch___rarg___boxed), 9, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_LibraryFacetDecl_fetch___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = l_Lake_LibraryFacetDecl_fetch___rarg(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +lean_dec(x_2); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Lake_LibraryFacetConfig_fetchJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; +x_10 = lean_ctor_get(x_3, 1); +lean_inc(x_10); +lean_dec(x_3); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_11 = 1; +x_12 = l_Lean_Name_toString(x_1, x_11); +x_13 = l_Lake_Module_fetchFacetJob___closed__1; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lake_PackageFacetConfig_fetchJob___closed__2; +x_16 = lean_string_append(x_14, x_15); +x_17 = 3; +x_18 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set_uint8(x_18, sizeof(void*)*1, x_17); +x_19 = lean_array_get_size(x_7); +x_20 = lean_array_push(x_7, x_18); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_8); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_9); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_10, 0); +lean_inc(x_24); +lean_dec(x_10); +x_25 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_25, 0, x_2); +lean_ctor_set(x_25, 1, x_1); +x_26 = lean_apply_6(x_4, x_25, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_26) == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_26, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +if (lean_obj_tag(x_28) == 0) +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_26); +if (x_29 == 0) +{ +lean_object* x_30; uint8_t x_31; +x_30 = lean_ctor_get(x_26, 0); +lean_dec(x_30); +x_31 = !lean_is_exclusive(x_27); +if (x_31 == 0) +{ +lean_object* x_32; uint8_t x_33; +x_32 = lean_ctor_get(x_27, 0); +lean_dec(x_32); +x_33 = !lean_is_exclusive(x_28); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; +x_34 = lean_ctor_get(x_28, 0); +x_35 = lean_apply_1(x_24, x_34); +lean_ctor_set(x_28, 0, x_35); +return x_26; +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_36 = lean_ctor_get(x_28, 0); +x_37 = lean_ctor_get(x_28, 1); +lean_inc(x_37); +lean_inc(x_36); +lean_dec(x_28); +x_38 = lean_apply_1(x_24, x_36); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_37); +lean_ctor_set(x_27, 0, x_39); +return x_26; +} +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_40 = lean_ctor_get(x_27, 1); +lean_inc(x_40); +lean_dec(x_27); +x_41 = lean_ctor_get(x_28, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_28, 1); +lean_inc(x_42); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_43 = x_28; +} else { + lean_dec_ref(x_28); + x_43 = lean_box(0); +} +x_44 = lean_apply_1(x_24, x_41); +if (lean_is_scalar(x_43)) { + x_45 = lean_alloc_ctor(0, 2, 0); +} else { + x_45 = x_43; +} +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_42); +x_46 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_40); +lean_ctor_set(x_26, 0, x_46); +return x_26; +} +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_47 = lean_ctor_get(x_26, 1); +lean_inc(x_47); +lean_dec(x_26); +x_48 = lean_ctor_get(x_27, 1); +lean_inc(x_48); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_49 = x_27; +} else { + lean_dec_ref(x_27); + x_49 = lean_box(0); +} +x_50 = lean_ctor_get(x_28, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_28, 1); +lean_inc(x_51); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_52 = x_28; +} else { + lean_dec_ref(x_28); + x_52 = lean_box(0); +} +x_53 = lean_apply_1(x_24, x_50); +if (lean_is_scalar(x_52)) { + x_54 = lean_alloc_ctor(0, 2, 0); +} else { + x_54 = x_52; +} +lean_ctor_set(x_54, 0, x_53); +lean_ctor_set(x_54, 1, x_51); +if (lean_is_scalar(x_49)) { + x_55 = lean_alloc_ctor(0, 2, 0); +} else { + x_55 = x_49; +} +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_48); +x_56 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_47); +return x_56; +} +} +else +{ +uint8_t x_57; +lean_dec(x_24); +x_57 = !lean_is_exclusive(x_26); +if (x_57 == 0) +{ +lean_object* x_58; uint8_t x_59; +x_58 = lean_ctor_get(x_26, 0); +lean_dec(x_58); +x_59 = !lean_is_exclusive(x_27); +if (x_59 == 0) +{ +lean_object* x_60; uint8_t x_61; +x_60 = lean_ctor_get(x_27, 0); +lean_dec(x_60); +x_61 = !lean_is_exclusive(x_28); +if (x_61 == 0) +{ +return x_26; +} +else +{ +lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_62 = lean_ctor_get(x_28, 0); +x_63 = lean_ctor_get(x_28, 1); +lean_inc(x_63); +lean_inc(x_62); +lean_dec(x_28); +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set(x_64, 1, x_63); +lean_ctor_set(x_27, 0, x_64); +return x_26; +} +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_65 = lean_ctor_get(x_27, 1); +lean_inc(x_65); +lean_dec(x_27); +x_66 = lean_ctor_get(x_28, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_28, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_68 = x_28; +} else { + lean_dec_ref(x_28); + x_68 = lean_box(0); +} +if (lean_is_scalar(x_68)) { + x_69 = lean_alloc_ctor(1, 2, 0); +} else { + x_69 = x_68; +} +lean_ctor_set(x_69, 0, x_66); +lean_ctor_set(x_69, 1, x_67); +x_70 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_65); +lean_ctor_set(x_26, 0, x_70); +return x_26; +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_71 = lean_ctor_get(x_26, 1); +lean_inc(x_71); +lean_dec(x_26); +x_72 = lean_ctor_get(x_27, 1); +lean_inc(x_72); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + lean_ctor_release(x_27, 1); + x_73 = x_27; +} else { + lean_dec_ref(x_27); + x_73 = lean_box(0); +} +x_74 = lean_ctor_get(x_28, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_28, 1); +lean_inc(x_75); +if (lean_is_exclusive(x_28)) { + lean_ctor_release(x_28, 0); + lean_ctor_release(x_28, 1); + x_76 = x_28; +} else { + lean_dec_ref(x_28); + x_76 = lean_box(0); +} +if (lean_is_scalar(x_76)) { + x_77 = lean_alloc_ctor(1, 2, 0); +} else { + x_77 = x_76; +} +lean_ctor_set(x_77, 0, x_74); +lean_ctor_set(x_77, 1, x_75); +if (lean_is_scalar(x_73)) { + x_78 = lean_alloc_ctor(0, 2, 0); +} else { + x_78 = x_73; +} +lean_ctor_set(x_78, 0, x_77); +lean_ctor_set(x_78, 1, x_72); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_71); +return x_79; +} +} +} +else +{ +uint8_t x_80; +lean_dec(x_24); +x_80 = !lean_is_exclusive(x_26); +if (x_80 == 0) +{ +return x_26; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_81 = lean_ctor_get(x_26, 0); +x_82 = lean_ctor_get(x_26, 1); +lean_inc(x_82); +lean_inc(x_81); +lean_dec(x_26); +x_83 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_83, 0, x_81); +lean_ctor_set(x_83, 1, x_82); +return x_83; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_LeanLib_fetchFacetJob(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_5, 1); +lean_inc(x_9); +x_10 = lean_ctor_get(x_9, 6); +lean_inc(x_10); +lean_dec(x_9); +x_11 = l_Lake_RBNode_dFind___at_Lake_Workspace_findLibraryFacetConfig_x3f___spec__1(x_10, x_1); +lean_dec(x_10); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_12 = 1; +x_13 = l_Lean_Name_toString(x_1, x_12); +x_14 = l_Lake_Module_fetchFacetJob___closed__1; +x_15 = lean_string_append(x_14, x_13); +lean_dec(x_13); +x_16 = l_Lake_TargetDecl_fetch___rarg___closed__2; +x_17 = lean_string_append(x_15, x_16); +x_18 = 3; +x_19 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = lean_array_get_size(x_6); +x_21 = lean_array_push(x_6, x_19); +x_22 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_22, 0, x_20); +lean_ctor_set(x_22, 1, x_21); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_7); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_8); +return x_24; +} +else +{ +lean_object* x_25; lean_object* x_26; +x_25 = lean_ctor_get(x_11, 0); +lean_inc(x_25); +lean_dec(x_11); +x_26 = lean_ctor_get(x_25, 1); +lean_inc(x_26); +lean_dec(x_25); +if (lean_obj_tag(x_26) == 0) +{ +uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_27 = 1; +x_28 = l_Lean_Name_toString(x_1, x_27); +x_29 = l_Lake_Module_fetchFacetJob___closed__1; +x_30 = lean_string_append(x_29, x_28); +lean_dec(x_28); +x_31 = l_Lake_PackageFacetConfig_fetchJob___closed__2; +x_32 = lean_string_append(x_30, x_31); +x_33 = 3; +x_34 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set_uint8(x_34, sizeof(void*)*1, x_33); +x_35 = lean_array_get_size(x_6); +x_36 = lean_array_push(x_6, x_34); +x_37 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +x_38 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_7); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_8); +return x_39; +} +else +{ +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_26, 0); +lean_inc(x_40); +lean_dec(x_26); +x_41 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_41, 0, x_2); +lean_ctor_set(x_41, 1, x_1); +x_42 = lean_apply_6(x_3, x_41, x_4, x_5, x_6, x_7, x_8); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +if (lean_obj_tag(x_44) == 0) +{ +uint8_t x_45; +x_45 = !lean_is_exclusive(x_42); +if (x_45 == 0) +{ +lean_object* x_46; uint8_t x_47; +x_46 = lean_ctor_get(x_42, 0); +lean_dec(x_46); +x_47 = !lean_is_exclusive(x_43); +if (x_47 == 0) +{ +lean_object* x_48; uint8_t x_49; +x_48 = lean_ctor_get(x_43, 0); +lean_dec(x_48); +x_49 = !lean_is_exclusive(x_44); +if (x_49 == 0) +{ +lean_object* x_50; lean_object* x_51; +x_50 = lean_ctor_get(x_44, 0); +x_51 = lean_apply_1(x_40, x_50); +lean_ctor_set(x_44, 0, x_51); +return x_42; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_44, 0); +x_53 = lean_ctor_get(x_44, 1); +lean_inc(x_53); +lean_inc(x_52); +lean_dec(x_44); +x_54 = lean_apply_1(x_40, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_53); +lean_ctor_set(x_43, 0, x_55); +return x_42; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_56 = lean_ctor_get(x_43, 1); +lean_inc(x_56); +lean_dec(x_43); +x_57 = lean_ctor_get(x_44, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_44, 1); +lean_inc(x_58); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_59 = x_44; +} else { + lean_dec_ref(x_44); + x_59 = lean_box(0); +} +x_60 = lean_apply_1(x_40, x_57); +if (lean_is_scalar(x_59)) { + x_61 = lean_alloc_ctor(0, 2, 0); +} else { + x_61 = x_59; +} +lean_ctor_set(x_61, 0, x_60); +lean_ctor_set(x_61, 1, x_58); +x_62 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_62, 0, x_61); +lean_ctor_set(x_62, 1, x_56); +lean_ctor_set(x_42, 0, x_62); +return x_42; +} +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_63 = lean_ctor_get(x_42, 1); +lean_inc(x_63); +lean_dec(x_42); +x_64 = lean_ctor_get(x_43, 1); +lean_inc(x_64); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_65 = x_43; +} else { + lean_dec_ref(x_43); + x_65 = lean_box(0); +} +x_66 = lean_ctor_get(x_44, 0); +lean_inc(x_66); +x_67 = lean_ctor_get(x_44, 1); +lean_inc(x_67); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_68 = x_44; +} else { + lean_dec_ref(x_44); + x_68 = lean_box(0); +} +x_69 = lean_apply_1(x_40, x_66); +if (lean_is_scalar(x_68)) { + x_70 = lean_alloc_ctor(0, 2, 0); +} else { + x_70 = x_68; +} +lean_ctor_set(x_70, 0, x_69); +lean_ctor_set(x_70, 1, x_67); +if (lean_is_scalar(x_65)) { + x_71 = lean_alloc_ctor(0, 2, 0); +} else { + x_71 = x_65; +} +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_64); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_63); +return x_72; +} +} +else +{ +uint8_t x_73; +lean_dec(x_40); +x_73 = !lean_is_exclusive(x_42); +if (x_73 == 0) +{ +lean_object* x_74; uint8_t x_75; +x_74 = lean_ctor_get(x_42, 0); +lean_dec(x_74); +x_75 = !lean_is_exclusive(x_43); +if (x_75 == 0) +{ +lean_object* x_76; uint8_t x_77; +x_76 = lean_ctor_get(x_43, 0); +lean_dec(x_76); +x_77 = !lean_is_exclusive(x_44); +if (x_77 == 0) +{ +return x_42; +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_78 = lean_ctor_get(x_44, 0); +x_79 = lean_ctor_get(x_44, 1); +lean_inc(x_79); +lean_inc(x_78); +lean_dec(x_44); +x_80 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_80, 0, x_78); +lean_ctor_set(x_80, 1, x_79); +lean_ctor_set(x_43, 0, x_80); +return x_42; +} +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_81 = lean_ctor_get(x_43, 1); +lean_inc(x_81); +lean_dec(x_43); +x_82 = lean_ctor_get(x_44, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_44, 1); +lean_inc(x_83); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_84 = x_44; +} else { + lean_dec_ref(x_44); + x_84 = lean_box(0); +} +if (lean_is_scalar(x_84)) { + x_85 = lean_alloc_ctor(1, 2, 0); +} else { + x_85 = x_84; +} +lean_ctor_set(x_85, 0, x_82); +lean_ctor_set(x_85, 1, x_83); +x_86 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_86, 0, x_85); +lean_ctor_set(x_86, 1, x_81); +lean_ctor_set(x_42, 0, x_86); +return x_42; +} +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_87 = lean_ctor_get(x_42, 1); +lean_inc(x_87); +lean_dec(x_42); +x_88 = lean_ctor_get(x_43, 1); +lean_inc(x_88); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_89 = x_43; +} else { + lean_dec_ref(x_43); + x_89 = lean_box(0); +} +x_90 = lean_ctor_get(x_44, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_44, 1); +lean_inc(x_91); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_92 = x_44; +} else { + lean_dec_ref(x_44); + x_92 = lean_box(0); +} +if (lean_is_scalar(x_92)) { + x_93 = lean_alloc_ctor(1, 2, 0); +} else { + x_93 = x_92; +} +lean_ctor_set(x_93, 0, x_90); +lean_ctor_set(x_93, 1, x_91); +if (lean_is_scalar(x_89)) { + x_94 = lean_alloc_ctor(0, 2, 0); +} else { + x_94 = x_89; +} +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_88); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_87); +return x_95; +} +} +} +else +{ +uint8_t x_96; +lean_dec(x_40); +x_96 = !lean_is_exclusive(x_42); +if (x_96 == 0) +{ +return x_42; +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_97 = lean_ctor_get(x_42, 0); +x_98 = lean_ctor_get(x_42, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_42); +x_99 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_99, 0, x_97); +lean_ctor_set(x_99, 1, x_98); +return x_99; +} +} +} +} +} +} +static lean_object* _init_l_Lake_LeanExeConfig_get___rarg___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lean executable '", 17); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_get___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_3); +x_5 = 1; +x_6 = l_Lean_Name_toString(x_1, x_5); +x_7 = l_Lake_LeanExeConfig_get___rarg___lambda__1___closed__1; +x_8 = lean_string_append(x_7, x_6); +lean_dec(x_6); +x_9 = l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2; +x_10 = lean_string_append(x_8, x_9); +x_11 = lean_apply_2(x_2, lean_box(0), x_10); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_2); +lean_dec(x_1); +x_12 = lean_ctor_get(x_4, 0); +lean_inc(x_12); +lean_dec(x_4); +x_13 = lean_ctor_get(x_3, 1); +lean_inc(x_13); +lean_dec(x_3); +x_14 = lean_apply_2(x_13, lean_box(0), x_12); +return x_14; +} +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_get___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_5 = lean_ctor_get(x_2, 1); +lean_inc(x_5); +x_6 = lean_ctor_get(x_2, 0); +lean_inc(x_6); +lean_dec(x_2); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +lean_dec(x_1); +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +lean_dec(x_7); +lean_inc(x_8); +x_10 = lean_alloc_closure((void*)(l_Lake_Workspace_findLeanExe_x3f___boxed), 2, 1); +lean_closure_set(x_10, 0, x_8); +x_11 = l_Lake_LeanLibConfig_get___rarg___closed__1; +lean_inc(x_9); +x_12 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_11, x_4); +x_13 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_10, x_12); +x_14 = lean_alloc_closure((void*)(l_Lake_LeanExeConfig_get___rarg___lambda__1), 4, 3); +lean_closure_set(x_14, 0, x_8); +lean_closure_set(x_14, 1, x_3); +lean_closure_set(x_14, 2, x_6); +x_15 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_13, x_14); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_get(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_LeanExeConfig_get___rarg), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExeConfig_fetch(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +lean_dec(x_1); +x_9 = lean_ctor_get(x_4, 1); +lean_inc(x_9); +x_10 = l_Lake_Workspace_findLeanExe_x3f(x_8, x_9); +lean_dec(x_9); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_11 = 1; +x_12 = l_Lean_Name_toString(x_8, x_11); +x_13 = l_Lake_LeanExeConfig_get___rarg___lambda__1___closed__1; +x_14 = lean_string_append(x_13, x_12); +lean_dec(x_12); +x_15 = l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2; +x_16 = lean_string_append(x_14, x_15); +x_17 = 3; +x_18 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set_uint8(x_18, sizeof(void*)*1, x_17); +x_19 = lean_array_get_size(x_5); +x_20 = lean_array_push(x_5, x_18); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_6); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_7); +return x_23; +} +else +{ +uint8_t x_24; +lean_dec(x_8); +x_24 = !lean_is_exclusive(x_10); +if (x_24 == 0) +{ +lean_object* x_25; +lean_ctor_set_tag(x_10, 3); +x_25 = lean_apply_6(x_2, x_10, x_3, x_4, x_5, x_6, x_7); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_10, 0); +lean_inc(x_26); +lean_dec(x_10); +x_27 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_27, 0, x_26); +x_28 = lean_apply_6(x_2, x_27, x_3, x_4, x_5, x_6, x_7); +return x_28; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_LeanExe_fetch(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_8, 0, x_1); +x_9 = lean_apply_6(x_2, x_8, x_3, x_4, x_5, x_6, x_7); +return x_9; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Config_Monad(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Targets(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Config_Monad(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_Package_fetchTargetJob___closed__1 = _init_l_Lake_Package_fetchTargetJob___closed__1(); +lean_mark_persistent(l_Lake_Package_fetchTargetJob___closed__1); +l_Lake_Package_fetchTargetJob___closed__2 = _init_l_Lake_Package_fetchTargetJob___closed__2(); +lean_mark_persistent(l_Lake_Package_fetchTargetJob___closed__2); +l_Lake_Package_fetchTargetJob___closed__3 = _init_l_Lake_Package_fetchTargetJob___closed__3(); +lean_mark_persistent(l_Lake_Package_fetchTargetJob___closed__3); +l_Lake_TargetDecl_fetch___rarg___closed__1 = _init_l_Lake_TargetDecl_fetch___rarg___closed__1(); +lean_mark_persistent(l_Lake_TargetDecl_fetch___rarg___closed__1); +l_Lake_TargetDecl_fetch___rarg___closed__2 = _init_l_Lake_TargetDecl_fetch___rarg___closed__2(); +lean_mark_persistent(l_Lake_TargetDecl_fetch___rarg___closed__2); +l_Lake_PackageFacetConfig_fetchJob___closed__1 = _init_l_Lake_PackageFacetConfig_fetchJob___closed__1(); +lean_mark_persistent(l_Lake_PackageFacetConfig_fetchJob___closed__1); +l_Lake_PackageFacetConfig_fetchJob___closed__2 = _init_l_Lake_PackageFacetConfig_fetchJob___closed__2(); +lean_mark_persistent(l_Lake_PackageFacetConfig_fetchJob___closed__2); +l_Lake_ModuleFacetConfig_fetchJob___closed__1 = _init_l_Lake_ModuleFacetConfig_fetchJob___closed__1(); +lean_mark_persistent(l_Lake_ModuleFacetConfig_fetchJob___closed__1); +l_Lake_Module_fetchFacetJob___closed__1 = _init_l_Lake_Module_fetchFacetJob___closed__1(); +lean_mark_persistent(l_Lake_Module_fetchFacetJob___closed__1); +l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__1 = _init_l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__1(); +lean_mark_persistent(l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__1); +l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2 = _init_l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2(); +lean_mark_persistent(l_Lake_LeanLibConfig_get___rarg___lambda__2___closed__2); +l_Lake_LeanLibConfig_get___rarg___closed__1 = _init_l_Lake_LeanLibConfig_get___rarg___closed__1(); +lean_mark_persistent(l_Lake_LeanLibConfig_get___rarg___closed__1); +l_Lake_LeanExeConfig_get___rarg___lambda__1___closed__1 = _init_l_Lake_LeanExeConfig_get___rarg___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_LeanExeConfig_get___rarg___lambda__1___closed__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Topological.c b/stage0/stdlib/Lake/Build/Topological.c new file mode 100644 index 0000000000..634a265a35 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Topological.c @@ -0,0 +1,415 @@ +// Lean compiler output +// Module: Lake.Build.Topological +// Imports: Init Lake.Util.Cycle Lake.Util.Store Lake.Util.EquipT +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +LEAN_EXPORT lean_object* l_Lake_recFetch___rarg(lean_object*, lean_object*); +LEAN_EXPORT uint8_t l_Lake_recFetchAcyclic___rarg___lambda__3(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__1(lean_object*, lean_object*, lean_object*); +lean_object* l_List_appendTR___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_partition_loop___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_recFetchAcyclic___rarg___lambda__4___closed__1; +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__3___boxed(lean_object*, lean_object*, lean_object*); +uint8_t l_List_elem___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetch(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_recFetch___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +lean_inc(x_1); +x_3 = lean_alloc_closure((void*)(l_Lake_recFetch___rarg), 2, 1); +lean_closure_set(x_3, 0, x_1); +x_4 = lean_apply_2(x_1, x_2, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetch(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_alloc_closure((void*)(l_Lake_recFetch___rarg), 2, 0); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = lean_apply_1(x_2, x_4); +x_7 = lean_apply_3(x_5, lean_box(0), x_3, x_6); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg___lambda__1), 4, 3); +lean_closure_set(x_6, 0, x_1); +lean_closure_set(x_6, 1, x_2); +lean_closure_set(x_6, 2, x_5); +x_7 = lean_apply_2(x_3, x_4, x_6); +return x_7; +} +} +LEAN_EXPORT uint8_t l_Lake_recFetchAcyclic___rarg___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; uint8_t x_5; +x_4 = lean_apply_2(x_1, x_3, x_2); +x_5 = lean_unbox(x_4); +lean_dec(x_4); +if (x_5 == 0) +{ +uint8_t x_6; +x_6 = 1; +return x_6; +} +else +{ +uint8_t x_7; +x_7 = 0; +return x_7; +} +} +} +static lean_object* _init_l_Lake_recFetchAcyclic___rarg___lambda__4___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_box(0); +x_2 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_2, 0, x_1); +lean_ctor_set(x_2, 1, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +lean_inc(x_6); +lean_inc(x_2); +lean_inc(x_1); +x_7 = l_List_elem___rarg(x_1, x_2, x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_dec(x_5); +lean_dec(x_1); +x_8 = lean_ctor_get(x_3, 1); +lean_inc(x_8); +lean_dec(x_3); +x_9 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_9, 0, x_2); +lean_ctor_set(x_9, 1, x_6); +x_10 = lean_apply_3(x_8, lean_box(0), x_9, x_4); +return x_10; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_dec(x_4); +lean_dec(x_3); +x_11 = lean_ctor_get(x_5, 1); +lean_inc(x_11); +lean_dec(x_5); +lean_inc(x_2); +x_12 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg___lambda__3___boxed), 3, 2); +lean_closure_set(x_12, 0, x_1); +lean_closure_set(x_12, 1, x_2); +x_13 = lean_box(0); +x_14 = l_Lake_recFetchAcyclic___rarg___lambda__4___closed__1; +x_15 = l_List_partition_loop___rarg(x_12, x_6, x_14); +x_16 = lean_ctor_get(x_15, 0); +lean_inc(x_16); +lean_dec(x_15); +lean_inc(x_2); +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_2); +lean_ctor_set(x_17, 1, x_16); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_2); +lean_ctor_set(x_18, 1, x_13); +x_19 = l_List_appendTR___rarg(x_17, x_18); +x_20 = lean_apply_2(x_11, lean_box(0), x_19); +return x_20; +} +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +lean_inc(x_6); +x_8 = lean_apply_1(x_1, x_6); +x_9 = lean_ctor_get(x_2, 1); +lean_inc(x_9); +lean_dec(x_2); +x_10 = lean_ctor_get(x_3, 0); +lean_inc(x_10); +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +lean_inc(x_10); +x_12 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg___lambda__2), 5, 4); +lean_closure_set(x_12, 0, x_10); +lean_closure_set(x_12, 1, x_7); +lean_closure_set(x_12, 2, x_4); +lean_closure_set(x_12, 3, x_6); +lean_inc(x_9); +lean_inc(x_11); +x_13 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_11, x_12); +x_14 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg___lambda__4), 6, 5); +lean_closure_set(x_14, 0, x_5); +lean_closure_set(x_14, 1, x_8); +lean_closure_set(x_14, 2, x_10); +lean_closure_set(x_14, 3, x_13); +lean_closure_set(x_14, 4, x_3); +x_15 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_11, x_14); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; +x_7 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg___lambda__5), 7, 5); +lean_closure_set(x_7, 0, x_4); +lean_closure_set(x_7, 1, x_2); +lean_closure_set(x_7, 2, x_3); +lean_closure_set(x_7, 3, x_5); +lean_closure_set(x_7, 4, x_1); +x_8 = l_Lake_recFetch___rarg(x_7, x_6); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg), 6, 0); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchAcyclic___rarg___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; lean_object* x_5; +x_4 = l_Lake_recFetchAcyclic___rarg___lambda__3(x_1, x_2, x_3); +x_5 = lean_box(x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = lean_ctor_get(x_4, 1); +lean_inc(x_5); +lean_dec(x_4); +x_6 = lean_apply_2(x_5, lean_box(0), x_2); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_6 = lean_ctor_get(x_1, 1); +lean_inc(x_6); +lean_dec(x_1); +lean_inc(x_5); +x_7 = lean_apply_2(x_6, x_2, x_5); +x_8 = lean_alloc_closure((void*)(l_Lake_recFetchMemoize___rarg___lambda__1___boxed), 3, 2); +lean_closure_set(x_8, 0, x_3); +lean_closure_set(x_8, 1, x_5); +x_9 = lean_apply_4(x_4, lean_box(0), lean_box(0), x_7, x_8); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; lean_object* x_8; +lean_inc(x_4); +x_7 = lean_alloc_closure((void*)(l_Lake_recFetchMemoize___rarg___lambda__2), 5, 4); +lean_closure_set(x_7, 0, x_1); +lean_closure_set(x_7, 1, x_2); +lean_closure_set(x_7, 2, x_3); +lean_closure_set(x_7, 3, x_4); +x_8 = lean_apply_4(x_4, lean_box(0), lean_box(0), x_5, x_7); +return x_8; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_9 = lean_ctor_get(x_6, 0); +lean_inc(x_9); +lean_dec(x_6); +x_10 = lean_ctor_get(x_3, 0); +lean_inc(x_10); +lean_dec(x_3); +x_11 = lean_ctor_get(x_10, 1); +lean_inc(x_11); +lean_dec(x_10); +x_12 = lean_apply_2(x_11, lean_box(0), x_9); +return x_12; +} +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_10 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg___lambda__1), 4, 3); +lean_closure_set(x_10, 0, x_1); +lean_closure_set(x_10, 1, x_2); +lean_closure_set(x_10, 2, x_9); +x_11 = lean_apply_2(x_3, x_4, x_10); +x_12 = lean_ctor_get(x_5, 0); +lean_inc(x_12); +lean_inc(x_6); +x_13 = lean_apply_1(x_12, x_6); +lean_inc(x_8); +x_14 = lean_alloc_closure((void*)(l_Lake_recFetchMemoize___rarg___lambda__3), 6, 5); +lean_closure_set(x_14, 0, x_5); +lean_closure_set(x_14, 1, x_6); +lean_closure_set(x_14, 2, x_7); +lean_closure_set(x_14, 3, x_8); +lean_closure_set(x_14, 4, x_11); +x_15 = lean_apply_4(x_8, lean_box(0), lean_box(0), x_13, x_14); +return x_15; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) { +_start: +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +lean_inc(x_7); +x_9 = lean_apply_1(x_1, x_7); +x_10 = lean_ctor_get(x_2, 1); +lean_inc(x_10); +x_11 = lean_ctor_get(x_3, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +lean_inc(x_10); +lean_inc(x_9); +lean_inc(x_11); +x_13 = lean_alloc_closure((void*)(l_Lake_recFetchMemoize___rarg___lambda__4), 9, 8); +lean_closure_set(x_13, 0, x_11); +lean_closure_set(x_13, 1, x_8); +lean_closure_set(x_13, 2, x_4); +lean_closure_set(x_13, 3, x_7); +lean_closure_set(x_13, 4, x_5); +lean_closure_set(x_13, 5, x_9); +lean_closure_set(x_13, 6, x_2); +lean_closure_set(x_13, 7, x_10); +lean_inc(x_10); +lean_inc(x_12); +x_14 = lean_apply_4(x_10, lean_box(0), lean_box(0), x_12, x_13); +x_15 = lean_alloc_closure((void*)(l_Lake_recFetchAcyclic___rarg___lambda__4), 6, 5); +lean_closure_set(x_15, 0, x_6); +lean_closure_set(x_15, 1, x_9); +lean_closure_set(x_15, 2, x_11); +lean_closure_set(x_15, 3, x_14); +lean_closure_set(x_15, 4, x_3); +x_16 = lean_apply_4(x_10, lean_box(0), lean_box(0), x_12, x_15); +return x_16; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_alloc_closure((void*)(l_Lake_recFetchMemoize___rarg___lambda__5), 8, 6); +lean_closure_set(x_8, 0, x_5); +lean_closure_set(x_8, 1, x_2); +lean_closure_set(x_8, 2, x_3); +lean_closure_set(x_8, 3, x_6); +lean_closure_set(x_8, 4, x_4); +lean_closure_set(x_8, 5, x_1); +x_9 = l_Lake_recFetch___rarg(x_8, x_7); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_alloc_closure((void*)(l_Lake_recFetchMemoize___rarg), 7, 0); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_recFetchMemoize___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_recFetchMemoize___rarg___lambda__1(x_1, x_2, x_3); +lean_dec(x_3); +return x_4; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Cycle(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_Store(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_EquipT(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Topological(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Cycle(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_Store(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_EquipT(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_recFetchAcyclic___rarg___lambda__4___closed__1 = _init_l_Lake_recFetchAcyclic___rarg___lambda__4___closed__1(); +lean_mark_persistent(l_Lake_recFetchAcyclic___rarg___lambda__4___closed__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/Build/Trace.c b/stage0/stdlib/Lake/Build/Trace.c new file mode 100644 index 0000000000..edcb37c3a1 --- /dev/null +++ b/stage0/stdlib/Lake/Build/Trace.c @@ -0,0 +1,3189 @@ +// Lean compiler output +// Module: Lake.Build.Trace +// Imports: Init Lake.Util.IO Lean.Data.Json +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_Hash_instMixTrace___closed__1; +LEAN_EXPORT lean_object* l_Lake_MTime_instOrd; +LEAN_EXPORT lean_object* l_Lake_computeHash___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__7; +LEAN_EXPORT lean_object* l_Lake_Hash_instToString; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstHash(lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__10; +LEAN_EXPORT lean_object* l_Lake_instComputeHashArrayOfMonad___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstFile___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_instToJson; +LEAN_EXPORT lean_object* l_Lake_computeListTrace___at_Lake_instComputeTraceListOfMonad___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeHashFilePathIO; +LEAN_EXPORT lean_object* l_Lake_instComputeTraceIOMTimeOfGetMTime___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_ofHash___boxed(lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5; +LEAN_EXPORT lean_object* l_Lake_mixTraceList___rarg(lean_object*, lean_object*, lean_object*); +uint64_t lean_uint64_of_nat(lean_object*); +uint64_t lean_uint64_mix_hash(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_String_toNat_x3f(lean_object*); +LEAN_EXPORT uint64_t l_Lake_Hash_ofNat(lean_object*); +uint64_t lean_byte_array_hash(lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeHash(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT uint64_t l_Lake_Hash_mix(uint64_t, uint64_t); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__8; +LEAN_EXPORT lean_object* l_Lake_computeListTrace(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__2; +LEAN_EXPORT lean_object* l_Lake_MTime_instBEq; +LEAN_EXPORT lean_object* l_Lake_computeTextFileHash(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace(lean_object*, lean_object*, lean_object*); +extern lean_object* l_IO_FS_instOrdSystemTime; +LEAN_EXPORT lean_object* l_Lake_computeTrace___rarg(lean_object*, lean_object*, lean_object*); +uint8_t lean_usize_dec_eq(size_t, size_t); +lean_object* l_List_foldlM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_metadata(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceListOfMonad(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceArrayOfMonad(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_toJson___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_ofNat___boxed(lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__11; +LEAN_EXPORT lean_object* l_Lake_instGetMTimeTextFilePath___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_instComputeHashStringId___closed__1; +uint64_t lean_string_hash(lean_object*); +extern lean_object* l_IO_FS_instReprSystemTime; +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__4; +uint8_t l_instDecidableRelLt___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_toJson(uint64_t); +LEAN_EXPORT lean_object* l_Lake_computeFileHash(lean_object*, lean_object*); +static lean_object* l_Lake_Hash_instToString___closed__1; +LEAN_EXPORT lean_object* l_Lake_Hash_toString___boxed(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_decEqHash____x40_Lake_Build_Trace___hyg_527____boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceHashOfComputeHash(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instBEqHash; +LEAN_EXPORT lean_object* l_Lake_MTime_instMin(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_mix(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstHash___rarg(lean_object*, lean_object*, uint64_t, lean_object*, lean_object*); +lean_object* l_List_foldl___rarg(lean_object*, lean_object*, lean_object*); +size_t lean_usize_of_nat(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceArrayOfMonad___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instReprBuildTrace___closed__1; +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__4; +LEAN_EXPORT lean_object* l_Lake_inhabitedOfNilTrace___rarg___boxed(lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__9; +lean_object* l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_2859_(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceHashOfComputeHash___rarg___boxed(lean_object*); +lean_object* l_Lake_createParentDirs(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____boxed(lean_object*, lean_object*); +static lean_object* l_Lake_MTime_instOfNat___closed__2; +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstTime(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getFileMTime___boxed(lean_object*, lean_object*); +lean_object* lean_nat_to_int(lean_object*); +static lean_object* l_Lake_Hash_fromJson_x3f___closed__1; +LEAN_EXPORT lean_object* l_Lake_instReprHash; +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__3; +LEAN_EXPORT lean_object* l_Lake_MTime_instNilTrace; +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__5; +static lean_object* l_Lake_computeTextFileHash___closed__1; +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace___at_Lake_instComputeTraceArrayOfMonad___spec__1(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstTime___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildTrace_instCoeHash___closed__1; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_writeToFile(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeListTrace___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instComputeTraceIOOfComputeHashOfMonadLiftTOfGetMTime(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceIOMTimeOfGetMTime___rarg___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_instFromJson; +lean_object* lean_uint64_to_nat(uint64_t); +LEAN_EXPORT lean_object* l_Lake_instCheckExistsFilePath; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instNilTrace; +lean_object* l_String_crlfToLf_go(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_inhabitedOfNilTrace(lean_object*); +static lean_object* l_Lake_instGetMTimeFilePath___closed__1; +static lean_object* l_Lake_Hash_fromJson_x3f___closed__2; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_ofMTime___boxed__const__1; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_ofMTime(lean_object*); +static lean_object* l_Lake_Hash_fromJson_x3f___closed__3; +LEAN_EXPORT lean_object* l_Lake_Hash_toString(uint64_t); +extern lean_object* l_IO_FS_instBEqSystemTime; +LEAN_EXPORT uint64_t l_Lake_Hash_ofString(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeHashStringId; +LEAN_EXPORT lean_object* l_Lake_instComputeHashTextFilePathIO(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_inhabitedOfNilTrace___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayHash(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstFile___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instMixTrace; +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__7; +lean_object* l_Lean_bignumFromJson_x3f(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_nil; +LEAN_EXPORT lean_object* l_Lake_computeFileHash___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_instComputeHashFilePathIO___closed__1; +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeListTrace___at_Lake_instComputeTraceListOfMonad___spec__1(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__3; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstHash___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_instReprHash___closed__1; +LEAN_EXPORT lean_object* l_Lake_Hash_fromJson_x3f___lambda__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceIOMTimeOfGetMTime(lean_object*); +LEAN_EXPORT uint8_t l_Lake_instDecidableEqHash(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace___at_Lake_instComputeTraceArrayOfMonad___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617_(uint64_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_mix___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mixTraceArray(lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_instOfNat; +LEAN_EXPORT lean_object* l_Lake_pureHash___rarg(lean_object*, lean_object*); +lean_object* l_IO_FS_readFile(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instGetMTimeFilePath; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__6; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_nil___closed__1___boxed__const__1; +static lean_object* l_Lake_Hash_instToJson___closed__1; +static lean_object* l_Lake_MTime_instOfNat___closed__1; +LEAN_EXPORT lean_object* l_Lake_Hash_load_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceHashOfComputeHash___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_ofHash(uint64_t); +LEAN_EXPORT lean_object* l_Lake_mixTraceArray___rarg___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_instMax(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_instRepr; +LEAN_EXPORT lean_object* l_Lake_Hash_load_x3f___boxed(lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__9; +lean_object* lean_string_length(lean_object*); +LEAN_EXPORT lean_object* l_Lake_getFileMTime(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__2; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___lambda__1(size_t, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mixTraceList(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_beqHash____x40_Lake_Build_Trace___hyg_465____boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324_(lean_object*, lean_object*); +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +LEAN_EXPORT uint64_t l_Lake_Hash_nil; +LEAN_EXPORT lean_object* l_Lake_instComputeHashArrayOfMonad(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instReprBuildTrace; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT uint64_t l_Lake_Hash_instNilTrace; +static lean_object* l_Lake_instCheckExistsFilePath___closed__1; +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__1(lean_object*, uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Lake_computeTextFileHash___boxed(lean_object*, lean_object*); +uint8_t l_instDecidableRelLe___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeTrace(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__1; +LEAN_EXPORT lean_object* l_Lake_Hash_ofByteArray___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeTraceListOfMonad___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instCoeMTime; +LEAN_EXPORT uint8_t l___private_Lake_Build_Trace_0__Lake_beqHash____x40_Lake_Build_Trace___hyg_465_(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_bignumToJson(lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t lean_uint64_dec_eq(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Lake_Hash_fromJson_x3f___lambda__1___boxed(lean_object*, lean_object*); +size_t lean_usize_add(size_t, size_t); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1___rarg(lean_object*, lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_pureHash(lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_instLT; +lean_object* lean_array_uget(lean_object*, size_t); +lean_object* l_Array_foldlMUnsafe_fold___rarg(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_instMixTrace(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instGetMTimeTextFilePath(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_MTime_instLE; +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instCoeHash; +lean_object* l_IO_FS_writeFile(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildTrace_instCoeMTime___closed__1; +LEAN_EXPORT uint8_t l___private_Lake_Build_Trace_0__Lake_decEqHash____x40_Lake_Build_Trace___hyg_527_(uint64_t, uint64_t); +LEAN_EXPORT lean_object* l_Lake_computeListTrace___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__12; +lean_object* lean_array_get_size(lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___boxed__const__1; +static lean_object* l_Lake_BuildTrace_instMixTrace___closed__1; +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__8; +lean_object* l_System_FilePath_pathExists___boxed(lean_object*, lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mixTraceArray___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__10; +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstFile(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instDecidableEqHash___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_BuildTrace_nil___closed__1; +lean_object* l_IO_FS_readBinFile(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instComputeHashTextFilePathIO___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_Hash_instFromJson___closed__1; +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__2(lean_object*, lean_object*, uint64_t, lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeListTrace___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeTextFilePathFilePath___boxed(lean_object*); +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_instMixTrace; +LEAN_EXPORT lean_object* l_Lake_Hash_ofString___boxed(lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__6; +LEAN_EXPORT uint64_t l_Lake_Hash_ofByteArray(lean_object*); +lean_object* l___private_Init_Data_Repr_0__Nat_reprFast(lean_object*); +LEAN_EXPORT lean_object* l_Lake_instCoeTextFilePathFilePath(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instComputeTraceIOOfComputeHashOfMonadLiftTOfGetMTime___rarg(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Hash_fromJson_x3f(lean_object*); +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg(lean_object*, lean_object*, lean_object*); +static lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__13; +static lean_object* l_Lake_instBEqHash___closed__1; +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* _init_l_Lake_instCheckExistsFilePath___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_System_FilePath_pathExists___boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instCheckExistsFilePath() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instCheckExistsFilePath___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_computeTrace___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_apply_1(x_1, x_3); +x_5 = lean_apply_2(x_2, lean_box(0), x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_computeTrace(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_alloc_closure((void*)(l_Lake_computeTrace___rarg), 3, 0); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_inhabitedOfNilTrace___rarg(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_inhabitedOfNilTrace(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_inhabitedOfNilTrace___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_inhabitedOfNilTrace___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_inhabitedOfNilTrace___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_mixTraceList___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_List_foldl___rarg(x_1, x_2, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_mixTraceList(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_mixTraceList___rarg), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1___rarg(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = lean_usize_dec_eq(x_3, x_4); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; size_t x_9; size_t x_10; +x_7 = lean_array_uget(x_2, x_3); +lean_inc(x_1); +x_8 = lean_apply_2(x_1, x_5, x_7); +x_9 = 1; +x_10 = lean_usize_add(x_3, x_9); +x_3 = x_10; +x_5 = x_8; +goto _start; +} +else +{ +lean_dec(x_1); +return x_5; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_mixTraceArray___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_4 = lean_array_get_size(x_3); +x_5 = lean_unsigned_to_nat(0u); +x_6 = lean_nat_dec_lt(x_5, x_4); +if (x_6 == 0) +{ +lean_dec(x_4); +lean_dec(x_1); +return x_2; +} +else +{ +uint8_t x_7; +x_7 = lean_nat_dec_le(x_4, x_4); +if (x_7 == 0) +{ +lean_dec(x_4); +lean_dec(x_1); +return x_2; +} +else +{ +size_t x_8; size_t x_9; lean_object* x_10; +x_8 = 0; +x_9 = lean_usize_of_nat(x_4); +lean_dec(x_4); +x_10 = l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1___rarg(x_1, x_3, x_8, x_9, x_2); +return x_10; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_mixTraceArray(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_mixTraceArray___rarg___boxed), 3, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +size_t x_6; size_t x_7; lean_object* x_8; +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_8 = l_Array_foldlMUnsafe_fold___at_Lake_mixTraceArray___spec__1___rarg(x_1, x_2, x_6, x_7, x_5); +lean_dec(x_2); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_mixTraceArray___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_mixTraceArray___rarg(x_1, x_2, x_3); +lean_dec(x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_computeListTrace___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_5 = lean_ctor_get(x_1, 0); +lean_inc(x_5); +lean_dec(x_1); +x_6 = lean_ctor_get(x_5, 1); +lean_inc(x_6); +lean_dec(x_5); +x_7 = lean_apply_2(x_2, x_3, x_4); +x_8 = lean_apply_2(x_6, lean_box(0), x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_computeListTrace___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_7 = lean_ctor_get(x_1, 1); +lean_inc(x_7); +x_8 = lean_apply_1(x_2, x_6); +x_9 = lean_apply_2(x_3, lean_box(0), x_8); +x_10 = lean_alloc_closure((void*)(l_Lake_computeListTrace___rarg___lambda__1), 4, 3); +lean_closure_set(x_10, 0, x_1); +lean_closure_set(x_10, 1, x_4); +lean_closure_set(x_10, 2, x_5); +x_11 = lean_apply_4(x_7, lean_box(0), lean_box(0), x_9, x_10); +return x_11; +} +} +LEAN_EXPORT lean_object* l_Lake_computeListTrace___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; +lean_inc(x_6); +x_8 = lean_alloc_closure((void*)(l_Lake_computeListTrace___rarg___lambda__2), 6, 4); +lean_closure_set(x_8, 0, x_6); +lean_closure_set(x_8, 1, x_3); +lean_closure_set(x_8, 2, x_5); +lean_closure_set(x_8, 3, x_1); +x_9 = l_List_foldlM___rarg(x_6, lean_box(0), lean_box(0), x_8, x_2, x_7); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_computeListTrace(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_computeListTrace___rarg), 7, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg(x_1, x_2, x_3, x_5, x_4); +return x_6; +} +} +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +lean_dec(x_2); +lean_dec(x_1); +x_6 = lean_ctor_get(x_3, 0); +lean_inc(x_6); +lean_dec(x_3); +x_7 = lean_ctor_get(x_6, 1); +lean_inc(x_7); +lean_dec(x_6); +x_8 = lean_apply_2(x_7, lean_box(0), x_4); +return x_8; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_9 = lean_ctor_get(x_5, 0); +lean_inc(x_9); +x_10 = lean_ctor_get(x_5, 1); +lean_inc(x_10); +lean_dec(x_5); +x_11 = lean_ctor_get(x_3, 1); +lean_inc(x_11); +lean_inc(x_2); +x_12 = lean_apply_1(x_2, x_9); +lean_inc(x_1); +lean_inc(x_3); +x_13 = lean_alloc_closure((void*)(l_Lake_computeListTrace___rarg___lambda__1), 4, 3); +lean_closure_set(x_13, 0, x_3); +lean_closure_set(x_13, 1, x_1); +lean_closure_set(x_13, 2, x_4); +lean_inc(x_11); +x_14 = lean_apply_4(x_11, lean_box(0), lean_box(0), x_12, x_13); +x_15 = lean_alloc_closure((void*)(l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg___lambda__1), 5, 4); +lean_closure_set(x_15, 0, x_1); +lean_closure_set(x_15, 1, x_2); +lean_closure_set(x_15, 2, x_3); +lean_closure_set(x_15, 3, x_10); +x_16 = lean_apply_4(x_11, lean_box(0), lean_box(0), x_14, x_15); +return x_16; +} +} +} +LEAN_EXPORT lean_object* l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg), 5, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_computeListTrace___at_Lake_instComputeTraceListOfMonad___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_List_foldlM___at_Lake_instComputeTraceListOfMonad___spec__2___rarg(x_1, x_3, x_4, x_2, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_computeListTrace___at_Lake_instComputeTraceListOfMonad___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_computeListTrace___at_Lake_instComputeTraceListOfMonad___spec__1___rarg), 5, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceListOfMonad___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_alloc_closure((void*)(l_Lake_computeListTrace___at_Lake_instComputeTraceListOfMonad___spec__1___rarg), 5, 4); +lean_closure_set(x_5, 0, x_1); +lean_closure_set(x_5, 1, x_2); +lean_closure_set(x_5, 2, x_3); +lean_closure_set(x_5, 3, x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceListOfMonad(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_instComputeTraceListOfMonad___rarg), 4, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; +lean_inc(x_6); +x_8 = lean_alloc_closure((void*)(l_Lake_computeListTrace___rarg___lambda__2), 6, 4); +lean_closure_set(x_8, 0, x_6); +lean_closure_set(x_8, 1, x_3); +lean_closure_set(x_8, 2, x_5); +lean_closure_set(x_8, 3, x_1); +x_9 = lean_array_get_size(x_7); +x_10 = lean_unsigned_to_nat(0u); +x_11 = lean_nat_dec_lt(x_10, x_9); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +x_12 = lean_ctor_get(x_6, 0); +lean_inc(x_12); +lean_dec(x_6); +x_13 = lean_ctor_get(x_12, 1); +lean_inc(x_13); +lean_dec(x_12); +x_14 = lean_apply_2(x_13, lean_box(0), x_2); +return x_14; +} +else +{ +uint8_t x_15; +x_15 = lean_nat_dec_le(x_9, x_9); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +x_16 = lean_ctor_get(x_6, 0); +lean_inc(x_16); +lean_dec(x_6); +x_17 = lean_ctor_get(x_16, 1); +lean_inc(x_17); +lean_dec(x_16); +x_18 = lean_apply_2(x_17, lean_box(0), x_2); +return x_18; +} +else +{ +size_t x_19; size_t x_20; lean_object* x_21; +x_19 = 0; +x_20 = lean_usize_of_nat(x_9); +lean_dec(x_9); +x_21 = l_Array_foldlMUnsafe_fold___rarg(x_6, x_8, x_7, x_19, x_20, x_2); +return x_21; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_computeArrayTrace___rarg), 7, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___lambda__1(size_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, size_t x_6, lean_object* x_7) { +_start: +{ +size_t x_8; size_t x_9; lean_object* x_10; +x_8 = 1; +x_9 = lean_usize_add(x_1, x_8); +x_10 = l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg(x_2, x_3, x_4, x_5, x_9, x_6, x_7); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, size_t x_5, size_t x_6, lean_object* x_7) { +_start: +{ +uint8_t x_8; +x_8 = lean_usize_dec_eq(x_5, x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_9 = lean_ctor_get(x_3, 1); +lean_inc(x_9); +x_10 = lean_array_uget(x_4, x_5); +lean_inc(x_2); +x_11 = lean_apply_1(x_2, x_10); +lean_inc(x_1); +lean_inc(x_3); +x_12 = lean_alloc_closure((void*)(l_Lake_computeListTrace___rarg___lambda__1), 4, 3); +lean_closure_set(x_12, 0, x_3); +lean_closure_set(x_12, 1, x_1); +lean_closure_set(x_12, 2, x_7); +lean_inc(x_9); +x_13 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_11, x_12); +x_14 = lean_box_usize(x_5); +x_15 = lean_box_usize(x_6); +x_16 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___lambda__1___boxed), 7, 6); +lean_closure_set(x_16, 0, x_14); +lean_closure_set(x_16, 1, x_1); +lean_closure_set(x_16, 2, x_2); +lean_closure_set(x_16, 3, x_3); +lean_closure_set(x_16, 4, x_4); +lean_closure_set(x_16, 5, x_15); +x_17 = lean_apply_4(x_9, lean_box(0), lean_box(0), x_13, x_16); +return x_17; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_18 = lean_ctor_get(x_3, 0); +lean_inc(x_18); +lean_dec(x_3); +x_19 = lean_ctor_get(x_18, 1); +lean_inc(x_19); +lean_dec(x_18); +x_20 = lean_apply_2(x_19, lean_box(0), x_7); +return x_20; +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___boxed), 7, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace___at_Lake_instComputeTraceArrayOfMonad___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_6 = lean_array_get_size(x_5); +x_7 = lean_unsigned_to_nat(0u); +x_8 = lean_nat_dec_lt(x_7, x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_1); +x_9 = lean_ctor_get(x_4, 0); +lean_inc(x_9); +lean_dec(x_4); +x_10 = lean_ctor_get(x_9, 1); +lean_inc(x_10); +lean_dec(x_9); +x_11 = lean_apply_2(x_10, lean_box(0), x_2); +return x_11; +} +else +{ +uint8_t x_12; +x_12 = lean_nat_dec_le(x_6, x_6); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_1); +x_13 = lean_ctor_get(x_4, 0); +lean_inc(x_13); +lean_dec(x_4); +x_14 = lean_ctor_get(x_13, 1); +lean_inc(x_14); +lean_dec(x_13); +x_15 = lean_apply_2(x_14, lean_box(0), x_2); +return x_15; +} +else +{ +size_t x_16; size_t x_17; lean_object* x_18; +x_16 = 0; +x_17 = lean_usize_of_nat(x_6); +lean_dec(x_6); +x_18 = l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg(x_1, x_3, x_4, x_5, x_16, x_17, x_2); +return x_18; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayTrace___at_Lake_instComputeTraceArrayOfMonad___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_computeArrayTrace___at_Lake_instComputeTraceArrayOfMonad___spec__1___rarg), 5, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceArrayOfMonad___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_alloc_closure((void*)(l_Lake_computeArrayTrace___at_Lake_instComputeTraceArrayOfMonad___spec__1___rarg), 5, 4); +lean_closure_set(x_5, 0, x_1); +lean_closure_set(x_5, 1, x_2); +lean_closure_set(x_5, 2, x_3); +lean_closure_set(x_5, 3, x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceArrayOfMonad(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_instComputeTraceArrayOfMonad___rarg), 4, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +size_t x_8; size_t x_9; lean_object* x_10; +x_8 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_9 = lean_unbox_usize(x_6); +lean_dec(x_6); +x_10 = l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___lambda__1(x_8, x_2, x_3, x_4, x_5, x_9, x_7); +return x_10; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +size_t x_8; size_t x_9; lean_object* x_10; +x_8 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_9 = lean_unbox_usize(x_6); +lean_dec(x_6); +x_10 = l_Array_foldlMUnsafe_fold___at_Lake_instComputeTraceArrayOfMonad___spec__2___rarg(x_1, x_2, x_3, x_4, x_8, x_9, x_7); +return x_10; +} +} +LEAN_EXPORT uint8_t l___private_Lake_Build_Trace_0__Lake_beqHash____x40_Lake_Build_Trace___hyg_465_(uint64_t x_1, uint64_t x_2) { +_start: +{ +uint8_t x_3; +x_3 = lean_uint64_dec_eq(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_beqHash____x40_Lake_Build_Trace___hyg_465____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint64_t x_3; uint64_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_4 = lean_unbox_uint64(x_2); +lean_dec(x_2); +x_5 = l___private_Lake_Build_Trace_0__Lake_beqHash____x40_Lake_Build_Trace___hyg_465_(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +static lean_object* _init_l_Lake_instBEqHash___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Trace_0__Lake_beqHash____x40_Lake_Build_Trace___hyg_465____boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instBEqHash() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instBEqHash___closed__1; +return x_1; +} +} +LEAN_EXPORT uint8_t l___private_Lake_Build_Trace_0__Lake_decEqHash____x40_Lake_Build_Trace___hyg_527_(uint64_t x_1, uint64_t x_2) { +_start: +{ +uint8_t x_3; +x_3 = lean_uint64_dec_eq(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_decEqHash____x40_Lake_Build_Trace___hyg_527____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint64_t x_3; uint64_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_4 = lean_unbox_uint64(x_2); +lean_dec(x_2); +x_5 = l___private_Lake_Build_Trace_0__Lake_decEqHash____x40_Lake_Build_Trace___hyg_527_(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +LEAN_EXPORT uint8_t l_Lake_instDecidableEqHash(uint64_t x_1, uint64_t x_2) { +_start: +{ +uint8_t x_3; +x_3 = lean_uint64_dec_eq(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instDecidableEqHash___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint64_t x_3; uint64_t x_4; uint8_t x_5; lean_object* x_6; +x_3 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_4 = lean_unbox_uint64(x_2); +lean_dec(x_2); +x_5 = l_Lake_instDecidableEqHash(x_3, x_4); +x_6 = lean_box(x_5); +return x_6; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("val", 3); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__1; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__2; +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" := ", 4); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__4; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__3; +x_2 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5; +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(7u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("{ ", 2); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__8; +x_2 = lean_string_length(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__9; +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__8; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__12() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" }", 2); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__12; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617_(uint64_t x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_3 = lean_uint64_to_nat(x_1); +x_4 = l___private_Init_Data_Repr_0__Nat_reprFast(x_3); +x_5 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_5, 0, x_4); +x_6 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__7; +x_7 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +x_8 = 0; +x_9 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_9, 0, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*1, x_8); +x_10 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__6; +x_11 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_11, 0, x_10); +lean_ctor_set(x_11, 1, x_9); +x_12 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__11; +x_13 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_11); +x_14 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__13; +x_15 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +x_16 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__10; +x_17 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +x_18 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_18, 0, x_17); +lean_ctor_set_uint8(x_18, sizeof(void*)*1, x_8); +return x_18; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint64_t x_3; lean_object* x_4; +x_3 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_4 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617_(x_3, x_2); +lean_dec(x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_instReprHash___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instReprHash() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instReprHash___closed__1; +return x_1; +} +} +LEAN_EXPORT uint64_t l_Lake_Hash_ofNat(lean_object* x_1) { +_start: +{ +uint64_t x_2; +x_2 = lean_uint64_of_nat(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_ofNat___boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = l_Lake_Hash_ofNat(x_1); +lean_dec(x_1); +x_3 = lean_box_uint64(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_load_x3f(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_IO_FS_readFile(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_3, 0); +x_6 = l_String_toNat_x3f(x_5); +lean_dec(x_5); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = lean_box(0); +lean_ctor_set(x_3, 0, x_7); +return x_3; +} +else +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_6); +if (x_8 == 0) +{ +lean_object* x_9; uint64_t x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_6, 0); +x_10 = lean_uint64_of_nat(x_9); +lean_dec(x_9); +x_11 = lean_box_uint64(x_10); +lean_ctor_set(x_6, 0, x_11); +lean_ctor_set(x_3, 0, x_6); +return x_3; +} +else +{ +lean_object* x_12; uint64_t x_13; lean_object* x_14; lean_object* x_15; +x_12 = lean_ctor_get(x_6, 0); +lean_inc(x_12); +lean_dec(x_6); +x_13 = lean_uint64_of_nat(x_12); +lean_dec(x_12); +x_14 = lean_box_uint64(x_13); +x_15 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_3, 0, x_15); +return x_3; +} +} +} +else +{ +lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_16 = lean_ctor_get(x_3, 0); +x_17 = lean_ctor_get(x_3, 1); +lean_inc(x_17); +lean_inc(x_16); +lean_dec(x_3); +x_18 = l_String_toNat_x3f(x_16); +lean_dec(x_16); +if (lean_obj_tag(x_18) == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_box(0); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_17); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; uint64_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_21 = lean_ctor_get(x_18, 0); +lean_inc(x_21); +if (lean_is_exclusive(x_18)) { + lean_ctor_release(x_18, 0); + x_22 = x_18; +} else { + lean_dec_ref(x_18); + x_22 = lean_box(0); +} +x_23 = lean_uint64_of_nat(x_21); +lean_dec(x_21); +x_24 = lean_box_uint64(x_23); +if (lean_is_scalar(x_22)) { + x_25 = lean_alloc_ctor(1, 1, 0); +} else { + x_25 = x_22; +} +lean_ctor_set(x_25, 0, x_24); +x_26 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_17); +return x_26; +} +} +} +else +{ +uint8_t x_27; +x_27 = !lean_is_exclusive(x_3); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_3, 0); +lean_dec(x_28); +x_29 = lean_box(0); +lean_ctor_set_tag(x_3, 0); +lean_ctor_set(x_3, 0, x_29); +return x_3; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_3, 1); +lean_inc(x_30); +lean_dec(x_3); +x_31 = lean_box(0); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_30); +return x_32; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_load_x3f___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_Hash_load_x3f(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +static uint64_t _init_l_Lake_Hash_nil() { +_start: +{ +uint64_t x_1; +x_1 = 1723; +return x_1; +} +} +static uint64_t _init_l_Lake_Hash_instNilTrace() { +_start: +{ +uint64_t x_1; +x_1 = l_Lake_Hash_nil; +return x_1; +} +} +LEAN_EXPORT uint64_t l_Lake_Hash_mix(uint64_t x_1, uint64_t x_2) { +_start: +{ +uint64_t x_3; +x_3 = lean_uint64_mix_hash(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_mix___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint64_t x_3; uint64_t x_4; uint64_t x_5; lean_object* x_6; +x_3 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_4 = lean_unbox_uint64(x_2); +lean_dec(x_2); +x_5 = l_Lake_Hash_mix(x_3, x_4); +x_6 = lean_box_uint64(x_5); +return x_6; +} +} +static lean_object* _init_l_Lake_Hash_instMixTrace___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Hash_mix___boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Hash_instMixTrace() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Hash_instMixTrace___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_toString(uint64_t x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = lean_uint64_to_nat(x_1); +x_3 = l___private_Init_Data_Repr_0__Nat_reprFast(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_toString___boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_3 = l_Lake_Hash_toString(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Hash_instToString___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Hash_toString___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Hash_instToString() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Hash_instToString___closed__1; +return x_1; +} +} +LEAN_EXPORT uint64_t l_Lake_Hash_ofString(lean_object* x_1) { +_start: +{ +uint64_t x_2; uint64_t x_3; uint64_t x_4; +x_2 = lean_string_hash(x_1); +x_3 = 1723; +x_4 = lean_uint64_mix_hash(x_3, x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_ofString___boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = l_Lake_Hash_ofString(x_1); +lean_dec(x_1); +x_3 = lean_box_uint64(x_2); +return x_3; +} +} +LEAN_EXPORT uint64_t l_Lake_Hash_ofByteArray(lean_object* x_1) { +_start: +{ +uint64_t x_2; +x_2 = lean_byte_array_hash(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_ofByteArray___boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = l_Lake_Hash_ofByteArray(x_1); +lean_dec(x_1); +x_3 = lean_box_uint64(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_toJson(uint64_t x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = lean_uint64_to_nat(x_1); +x_3 = l_Lean_bignumToJson(x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_toJson___boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_3 = l_Lake_Hash_toJson(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Hash_instToJson___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Hash_toJson___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Hash_instToJson() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Hash_instToJson___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_fromJson_x3f___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint64_t x_3; lean_object* x_4; lean_object* x_5; +x_3 = lean_uint64_of_nat(x_1); +x_4 = lean_box_uint64(x_3); +x_5 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_5, 0, x_4); +return x_5; +} +} +static lean_object* _init_l_Lake_Hash_fromJson_x3f___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_cstr_to_nat("18446744073709551616"); +return x_1; +} +} +static lean_object* _init_l_Lake_Hash_fromJson_x3f___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("value '{j}' is too large for `UInt64`", 37); +return x_1; +} +} +static lean_object* _init_l_Lake_Hash_fromJson_x3f___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_Hash_fromJson_x3f___closed__2; +x_2 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_fromJson_x3f(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_bignumFromJson_x3f(x_1); +if (lean_obj_tag(x_2) == 0) +{ +uint8_t x_3; +x_3 = !lean_is_exclusive(x_2); +if (x_3 == 0) +{ +return x_2; +} +else +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_ctor_get(x_2, 0); +lean_inc(x_4); +lean_dec(x_2); +x_5 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_5, 0, x_4); +return x_5; +} +} +else +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; +x_6 = lean_ctor_get(x_2, 0); +lean_inc(x_6); +lean_dec(x_2); +x_7 = l_Lake_Hash_fromJson_x3f___closed__1; +x_8 = lean_nat_dec_le(x_7, x_6); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; uint8_t x_11; +x_9 = lean_box(0); +x_10 = l_Lake_Hash_fromJson_x3f___lambda__1(x_6, x_9); +lean_dec(x_6); +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +return x_10; +} +else +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_13, 0, x_12); +return x_13; +} +} +else +{ +lean_object* x_14; +lean_dec(x_6); +x_14 = l_Lake_Hash_fromJson_x3f___closed__3; +return x_14; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Hash_fromJson_x3f___lambda__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_Hash_fromJson_x3f___lambda__1(x_1, x_2); +lean_dec(x_2); +lean_dec(x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_Hash_instFromJson___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Hash_fromJson_x3f), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Hash_instFromJson() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_Hash_instFromJson___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceHashOfComputeHash___rarg(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceHashOfComputeHash(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_instComputeTraceHashOfComputeHash___rarg___boxed), 1, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceHashOfComputeHash___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_instComputeTraceHashOfComputeHash___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_pureHash___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_apply_1(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_pureHash(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_pureHash___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_computeHash___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = lean_apply_1(x_1, x_3); +x_5 = lean_apply_2(x_2, lean_box(0), x_4); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Lake_computeHash(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_computeHash___rarg), 3, 0); +return x_4; +} +} +static lean_object* _init_l_Lake_instComputeHashStringId___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Hash_ofString___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instComputeHashStringId() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instComputeHashStringId___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_computeFileHash(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_IO_FS_readBinFile(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; uint64_t x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_byte_array_hash(x_5); +lean_dec(x_5); +x_7 = lean_box_uint64(x_6); +lean_ctor_set(x_3, 0, x_7); +return x_3; +} +else +{ +lean_object* x_8; lean_object* x_9; uint64_t x_10; lean_object* x_11; lean_object* x_12; +x_8 = lean_ctor_get(x_3, 0); +x_9 = lean_ctor_get(x_3, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_3); +x_10 = lean_byte_array_hash(x_8); +lean_dec(x_8); +x_11 = lean_box_uint64(x_10); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_9); +return x_12; +} +} +else +{ +uint8_t x_13; +x_13 = !lean_is_exclusive(x_3); +if (x_13 == 0) +{ +return x_3; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_3, 0); +x_15 = lean_ctor_get(x_3, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_3); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_14); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computeFileHash___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_computeFileHash(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_instComputeHashFilePathIO___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_computeFileHash___boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instComputeHashFilePathIO() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instComputeHashFilePathIO___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_computeTextFileHash___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_computeTextFileHash(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_IO_FS_readFile(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint64_t x_9; uint64_t x_10; uint64_t x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_3, 0); +x_6 = l_Lake_computeTextFileHash___closed__1; +x_7 = lean_unsigned_to_nat(0u); +x_8 = l_String_crlfToLf_go(x_5, x_6, x_7, x_7); +lean_dec(x_5); +x_9 = lean_string_hash(x_8); +lean_dec(x_8); +x_10 = 1723; +x_11 = lean_uint64_mix_hash(x_10, x_9); +x_12 = lean_box_uint64(x_11); +lean_ctor_set(x_3, 0, x_12); +return x_3; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint64_t x_18; uint64_t x_19; uint64_t x_20; lean_object* x_21; lean_object* x_22; +x_13 = lean_ctor_get(x_3, 0); +x_14 = lean_ctor_get(x_3, 1); +lean_inc(x_14); +lean_inc(x_13); +lean_dec(x_3); +x_15 = l_Lake_computeTextFileHash___closed__1; +x_16 = lean_unsigned_to_nat(0u); +x_17 = l_String_crlfToLf_go(x_13, x_15, x_16, x_16); +lean_dec(x_13); +x_18 = lean_string_hash(x_17); +lean_dec(x_17); +x_19 = 1723; +x_20 = lean_uint64_mix_hash(x_19, x_18); +x_21 = lean_box_uint64(x_20); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_14); +return x_22; +} +} +else +{ +uint8_t x_23; +x_23 = !lean_is_exclusive(x_3); +if (x_23 == 0) +{ +return x_3; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_3, 0); +x_25 = lean_ctor_get(x_3, 1); +lean_inc(x_25); +lean_inc(x_24); +lean_dec(x_3); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_24); +lean_ctor_set(x_26, 1, x_25); +return x_26; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computeTextFileHash___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_computeTextFileHash(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeTextFilePathFilePath(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instCoeTextFilePathFilePath___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_instCoeTextFilePathFilePath(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeHashTextFilePathIO(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_computeTextFileHash(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeHashTextFilePathIO___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_instComputeHashTextFilePathIO(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__1(lean_object* x_1, uint64_t x_2, uint64_t x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; uint64_t x_6; lean_object* x_7; lean_object* x_8; +x_4 = lean_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +x_5 = lean_ctor_get(x_4, 1); +lean_inc(x_5); +lean_dec(x_4); +x_6 = lean_uint64_mix_hash(x_2, x_3); +x_7 = lean_box_uint64(x_6); +x_8 = lean_apply_2(x_5, lean_box(0), x_7); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__2(lean_object* x_1, lean_object* x_2, uint64_t x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +x_6 = lean_apply_1(x_2, x_4); +x_7 = lean_box_uint64(x_3); +x_8 = lean_alloc_closure((void*)(l_Lake_computeArrayHash___rarg___lambda__1___boxed), 3, 2); +lean_closure_set(x_8, 0, x_1); +lean_closure_set(x_8, 1, x_7); +x_9 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_6, x_8); +return x_9; +} +} +static lean_object* _init_l_Lake_computeArrayHash___rarg___boxed__const__1() { +_start: +{ +uint64_t x_1; lean_object* x_2; +x_1 = l_Lake_Hash_nil; +x_2 = lean_box_uint64(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; +lean_inc(x_2); +x_4 = lean_alloc_closure((void*)(l_Lake_computeArrayHash___rarg___lambda__2___boxed), 4, 2); +lean_closure_set(x_4, 0, x_2); +lean_closure_set(x_4, 1, x_1); +x_5 = lean_array_get_size(x_3); +x_6 = lean_unsigned_to_nat(0u); +x_7 = lean_nat_dec_lt(x_6, x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +x_8 = lean_ctor_get(x_2, 0); +lean_inc(x_8); +lean_dec(x_2); +x_9 = lean_ctor_get(x_8, 1); +lean_inc(x_9); +lean_dec(x_8); +x_10 = l_Lake_computeArrayHash___rarg___boxed__const__1; +x_11 = lean_apply_2(x_9, lean_box(0), x_10); +return x_11; +} +else +{ +uint8_t x_12; +x_12 = lean_nat_dec_le(x_5, x_5); +if (x_12 == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +x_13 = lean_ctor_get(x_2, 0); +lean_inc(x_13); +lean_dec(x_2); +x_14 = lean_ctor_get(x_13, 1); +lean_inc(x_14); +lean_dec(x_13); +x_15 = l_Lake_computeArrayHash___rarg___boxed__const__1; +x_16 = lean_apply_2(x_14, lean_box(0), x_15); +return x_16; +} +else +{ +size_t x_17; size_t x_18; lean_object* x_19; lean_object* x_20; +x_17 = 0; +x_18 = lean_usize_of_nat(x_5); +lean_dec(x_5); +x_19 = l_Lake_computeArrayHash___rarg___boxed__const__1; +x_20 = l_Array_foldlMUnsafe_fold___rarg(x_2, x_4, x_3, x_17, x_18, x_19); +return x_20; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayHash(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_computeArrayHash___rarg), 3, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint64_t x_4; uint64_t x_5; lean_object* x_6; +x_4 = lean_unbox_uint64(x_2); +lean_dec(x_2); +x_5 = lean_unbox_uint64(x_3); +lean_dec(x_3); +x_6 = l_Lake_computeArrayHash___rarg___lambda__1(x_1, x_4, x_5); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_computeArrayHash___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint64_t x_5; lean_object* x_6; +x_5 = lean_unbox_uint64(x_3); +lean_dec(x_3); +x_6 = l_Lake_computeArrayHash___rarg___lambda__2(x_1, x_2, x_5, x_4); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeHashArrayOfMonad___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_computeArrayHash___rarg), 3, 2); +lean_closure_set(x_3, 0, x_1); +lean_closure_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeHashArrayOfMonad(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_instComputeHashArrayOfMonad___rarg), 2, 0); +return x_3; +} +} +static lean_object* _init_l_Lake_MTime_instOfNat___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_MTime_instOfNat___closed__2() { +_start: +{ +uint32_t x_1; lean_object* x_2; lean_object* x_3; +x_1 = 0; +x_2 = l_Lake_MTime_instOfNat___closed__1; +x_3 = lean_alloc_ctor(0, 1, 4); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set_uint32(x_3, sizeof(void*)*1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_MTime_instOfNat() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_MTime_instOfNat___closed__2; +return x_1; +} +} +static lean_object* _init_l_Lake_MTime_instBEq() { +_start: +{ +lean_object* x_1; +x_1 = l_IO_FS_instBEqSystemTime; +return x_1; +} +} +static lean_object* _init_l_Lake_MTime_instRepr() { +_start: +{ +lean_object* x_1; +x_1 = l_IO_FS_instReprSystemTime; +return x_1; +} +} +static lean_object* _init_l_Lake_MTime_instOrd() { +_start: +{ +lean_object* x_1; +x_1 = l_IO_FS_instOrdSystemTime; +return x_1; +} +} +static lean_object* _init_l_Lake_MTime_instLT() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(0); +return x_1; +} +} +static lean_object* _init_l_Lake_MTime_instLE() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_instMin(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = l_Lake_MTime_instOrd; +lean_inc(x_2); +lean_inc(x_1); +x_4 = l_instDecidableRelLe___rarg(x_3, x_1, x_2); +if (x_4 == 0) +{ +lean_dec(x_1); +return x_2; +} +else +{ +lean_dec(x_2); +return x_1; +} +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_instMax(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = l_Lake_MTime_instOrd; +lean_inc(x_2); +lean_inc(x_1); +x_4 = l_instDecidableRelLe___rarg(x_3, x_1, x_2); +if (x_4 == 0) +{ +lean_dec(x_2); +return x_1; +} +else +{ +lean_dec(x_1); +return x_2; +} +} +} +static lean_object* _init_l_Lake_MTime_instNilTrace() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_MTime_instOfNat___closed__2; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_instMixTrace(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; uint8_t x_4; +x_3 = l_Lake_MTime_instOrd; +lean_inc(x_2); +lean_inc(x_1); +x_4 = l_instDecidableRelLe___rarg(x_3, x_1, x_2); +if (x_4 == 0) +{ +lean_dec(x_2); +return x_1; +} +else +{ +lean_dec(x_1); +return x_2; +} +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceIOMTimeOfGetMTime___rarg(lean_object* x_1) { +_start: +{ +lean_inc(x_1); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceIOMTimeOfGetMTime(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_instComputeTraceIOMTimeOfGetMTime___rarg___boxed), 1, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_instComputeTraceIOMTimeOfGetMTime___rarg___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lake_instComputeTraceIOMTimeOfGetMTime___rarg(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_getFileMTime(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_io_metadata(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_5, 1); +lean_inc(x_6); +lean_dec(x_5); +lean_ctor_set(x_3, 0, x_6); +return x_3; +} +else +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_7 = lean_ctor_get(x_3, 0); +x_8 = lean_ctor_get(x_3, 1); +lean_inc(x_8); +lean_inc(x_7); +lean_dec(x_3); +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_8); +return x_10; +} +} +else +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_3); +if (x_11 == 0) +{ +return x_3; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_3, 0); +x_13 = lean_ctor_get(x_3, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_3); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_13); +return x_14; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_getFileMTime___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_getFileMTime(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_instGetMTimeFilePath___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_getFileMTime___boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instGetMTimeFilePath() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instGetMTimeFilePath___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_instGetMTimeTextFilePath(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_io_metadata(x_1, x_2); +if (lean_obj_tag(x_3) == 0) +{ +uint8_t x_4; +x_4 = !lean_is_exclusive(x_3); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_3, 0); +x_6 = lean_ctor_get(x_5, 1); +lean_inc(x_6); +lean_dec(x_5); +lean_ctor_set(x_3, 0, x_6); +return x_3; +} +else +{ +lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_7 = lean_ctor_get(x_3, 0); +x_8 = lean_ctor_get(x_3, 1); +lean_inc(x_8); +lean_inc(x_7); +lean_dec(x_3); +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_8); +return x_10; +} +} +else +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_3); +if (x_11 == 0) +{ +return x_3; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_3, 0); +x_13 = lean_ctor_get(x_3, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_3); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_13); +return x_14; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_instGetMTimeTextFilePath___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_instGetMTimeTextFilePath(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = lean_apply_2(x_1, x_2, x_4); +if (lean_obj_tag(x_5) == 0) +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; +x_7 = lean_ctor_get(x_5, 0); +x_8 = l_Lake_MTime_instOrd; +x_9 = l_instDecidableRelLt___rarg(x_8, x_3, x_7); +x_10 = lean_box(x_9); +lean_ctor_set(x_5, 0, x_10); +return x_5; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_5, 0); +x_12 = lean_ctor_get(x_5, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_5); +x_13 = l_Lake_MTime_instOrd; +x_14 = l_instDecidableRelLt___rarg(x_13, x_3, x_11); +x_15 = lean_box(x_14); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_12); +return x_16; +} +} +else +{ +uint8_t x_17; +lean_dec(x_3); +x_17 = !lean_is_exclusive(x_5); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_5, 0); +lean_dec(x_18); +x_19 = 0; +x_20 = lean_box(x_19); +lean_ctor_set_tag(x_5, 0); +lean_ctor_set(x_5, 0, x_20); +return x_5; +} +else +{ +lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_5, 1); +lean_inc(x_21); +lean_dec(x_5); +x_22 = 0; +x_23 = lean_box(x_22); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_21); +return x_24; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_MTime_checkUpToDate(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_MTime_checkUpToDate___rarg), 4, 0); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("hash", 4); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__1; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__2; +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__3; +x_2 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5; +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(8u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(",", 1); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__6; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("mtime", 5); +return x_1; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__9() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__8; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(9u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324_(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; uint64_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_unsigned_to_nat(0u); +x_5 = lean_unbox_uint64(x_3); +lean_dec(x_3); +x_6 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617_(x_5, x_4); +x_7 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__5; +x_8 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_6); +x_9 = 0; +x_10 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_10, 0, x_8); +lean_ctor_set_uint8(x_10, sizeof(void*)*1, x_9); +x_11 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__4; +x_12 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_10); +x_13 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__7; +x_14 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_13); +x_15 = lean_box(1); +x_16 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_16, 0, x_14); +lean_ctor_set(x_16, 1, x_15); +x_17 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__9; +x_18 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_18, 0, x_16); +lean_ctor_set(x_18, 1, x_17); +x_19 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5; +x_20 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_20, 0, x_18); +lean_ctor_set(x_20, 1, x_19); +x_21 = lean_ctor_get(x_1, 1); +lean_inc(x_21); +lean_dec(x_1); +x_22 = l___private_Init_System_IO_0__IO_FS_reprSystemTime____x40_Init_System_IO___hyg_2859_(x_21, x_4); +lean_dec(x_21); +x_23 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__10; +x_24 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +x_25 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set_uint8(x_25, sizeof(void*)*1, x_9); +x_26 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_26, 0, x_20); +lean_ctor_set(x_26, 1, x_25); +x_27 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__11; +x_28 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_26); +x_29 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__13; +x_30 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +x_31 = l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__10; +x_32 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_30); +x_33 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_33, 0, x_32); +lean_ctor_set_uint8(x_33, sizeof(void*)*1, x_9); +return x_33; +} +} +LEAN_EXPORT lean_object* l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324_(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instReprBuildTrace___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instReprBuildTrace() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instReprBuildTrace___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_ofHash(uint64_t x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_2 = l_Lake_MTime_instOfNat___closed__2; +x_3 = lean_box_uint64(x_1); +x_4 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_4, 0, x_3); +lean_ctor_set(x_4, 1, x_2); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_ofHash___boxed(lean_object* x_1) { +_start: +{ +uint64_t x_2; lean_object* x_3; +x_2 = lean_unbox_uint64(x_1); +lean_dec(x_1); +x_3 = l_Lake_BuildTrace_ofHash(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildTrace_instCoeHash___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildTrace_ofHash___boxed), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildTrace_instCoeHash() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildTrace_instCoeHash___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_BuildTrace_ofMTime___boxed__const__1() { +_start: +{ +uint64_t x_1; lean_object* x_2; +x_1 = l_Lake_Hash_nil; +x_2 = lean_box_uint64(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_ofMTime(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; +x_2 = l_Lake_BuildTrace_ofMTime___boxed__const__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildTrace_instCoeMTime___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildTrace_ofMTime), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildTrace_instCoeMTime() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildTrace_instCoeMTime___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_BuildTrace_nil___closed__1___boxed__const__1() { +_start: +{ +uint64_t x_1; lean_object* x_2; +x_1 = l_Lake_Hash_nil; +x_2 = lean_box_uint64(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_BuildTrace_nil___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_MTime_instOfNat___closed__2; +x_2 = l_Lake_BuildTrace_nil___closed__1___boxed__const__1; +x_3 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_3, 0, x_2); +lean_ctor_set(x_3, 1, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_BuildTrace_nil() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildTrace_nil___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_BuildTrace_instNilTrace() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildTrace_nil; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; +lean_inc(x_4); +x_6 = lean_apply_1(x_1, x_4); +x_7 = lean_apply_3(x_2, lean_box(0), x_6, x_5); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_apply_2(x_3, x_4, x_9); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_10, 0); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_8); +lean_ctor_set(x_13, 1, x_12); +lean_ctor_set(x_10, 0, x_13); +return x_10; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_14 = lean_ctor_get(x_10, 0); +x_15 = lean_ctor_get(x_10, 1); +lean_inc(x_15); +lean_inc(x_14); +lean_dec(x_10); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_8); +lean_ctor_set(x_16, 1, x_14); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +return x_17; +} +} +else +{ +uint8_t x_18; +lean_dec(x_8); +x_18 = !lean_is_exclusive(x_10); +if (x_18 == 0) +{ +return x_10; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_10, 0); +x_20 = lean_ctor_get(x_10, 1); +lean_inc(x_20); +lean_inc(x_19); +lean_dec(x_10); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +return x_21; +} +} +} +else +{ +uint8_t x_22; +lean_dec(x_4); +lean_dec(x_3); +x_22 = !lean_is_exclusive(x_7); +if (x_22 == 0) +{ +return x_7; +} +else +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_7, 0); +x_24 = lean_ctor_get(x_7, 1); +lean_inc(x_24); +lean_inc(x_23); +lean_dec(x_7); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +return x_25; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_compute(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildTrace_compute___rarg), 5, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instComputeTraceIOOfComputeHashOfMonadLiftTOfGetMTime___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_BuildTrace_compute___rarg), 5, 3); +lean_closure_set(x_4, 0, x_1); +lean_closure_set(x_4, 1, x_2); +lean_closure_set(x_4, 2, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_instComputeTraceIOOfComputeHashOfMonadLiftTOfGetMTime(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_BuildTrace_instComputeTraceIOOfComputeHashOfMonadLiftTOfGetMTime___rarg), 3, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_mix(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; uint8_t x_5; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +x_4 = lean_ctor_get(x_1, 1); +lean_inc(x_4); +lean_dec(x_1); +x_5 = !lean_is_exclusive(x_2); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; uint64_t x_8; uint64_t x_9; uint64_t x_10; lean_object* x_11; uint8_t x_12; +x_6 = lean_ctor_get(x_2, 0); +x_7 = lean_ctor_get(x_2, 1); +x_8 = lean_unbox_uint64(x_3); +lean_dec(x_3); +x_9 = lean_unbox_uint64(x_6); +lean_dec(x_6); +x_10 = lean_uint64_mix_hash(x_8, x_9); +x_11 = l_Lake_MTime_instOrd; +lean_inc(x_7); +lean_inc(x_4); +x_12 = l_instDecidableRelLe___rarg(x_11, x_4, x_7); +if (x_12 == 0) +{ +lean_object* x_13; +lean_dec(x_7); +x_13 = lean_box_uint64(x_10); +lean_ctor_set(x_2, 1, x_4); +lean_ctor_set(x_2, 0, x_13); +return x_2; +} +else +{ +lean_object* x_14; +lean_dec(x_4); +x_14 = lean_box_uint64(x_10); +lean_ctor_set(x_2, 0, x_14); +return x_2; +} +} +else +{ +lean_object* x_15; lean_object* x_16; uint64_t x_17; uint64_t x_18; uint64_t x_19; lean_object* x_20; uint8_t x_21; +x_15 = lean_ctor_get(x_2, 0); +x_16 = lean_ctor_get(x_2, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_2); +x_17 = lean_unbox_uint64(x_3); +lean_dec(x_3); +x_18 = lean_unbox_uint64(x_15); +lean_dec(x_15); +x_19 = lean_uint64_mix_hash(x_17, x_18); +x_20 = l_Lake_MTime_instOrd; +lean_inc(x_16); +lean_inc(x_4); +x_21 = l_instDecidableRelLe___rarg(x_20, x_4, x_16); +if (x_21 == 0) +{ +lean_object* x_22; lean_object* x_23; +lean_dec(x_16); +x_22 = lean_box_uint64(x_19); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_4); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; +lean_dec(x_4); +x_24 = lean_box_uint64(x_19); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_16); +return x_25; +} +} +} +} +static lean_object* _init_l_Lake_BuildTrace_instMixTrace___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildTrace_mix), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildTrace_instMixTrace() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_BuildTrace_instMixTrace___closed__1; +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstHash___rarg(lean_object* x_1, lean_object* x_2, uint64_t x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; uint64_t x_7; uint8_t x_8; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_unbox_uint64(x_6); +lean_dec(x_6); +x_8 = lean_uint64_dec_eq(x_3, x_7); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +lean_dec(x_2); +lean_dec(x_1); +x_9 = lean_box(x_8); +x_10 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_10, 0, x_9); +lean_ctor_set(x_10, 1, x_5); +return x_10; +} +else +{ +lean_object* x_11; +x_11 = lean_apply_2(x_1, x_2, x_5); +return x_11; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstHash(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildTrace_checkAgainstHash___rarg___boxed), 5, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstHash___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +uint64_t x_6; lean_object* x_7; +x_6 = lean_unbox_uint64(x_3); +lean_dec(x_3); +x_7 = l_Lake_BuildTrace_checkAgainstHash___rarg(x_1, x_2, x_6, x_4, x_5); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstTime___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; +x_5 = lean_ctor_get(x_3, 1); +lean_inc(x_5); +lean_dec(x_3); +x_6 = l_Lake_MTime_checkUpToDate___rarg(x_1, x_2, x_5, x_4); +return x_6; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstTime(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildTrace_checkAgainstTime___rarg), 4, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstFile___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; +x_7 = l_Lake_Hash_load_x3f(x_4, x_6); +x_8 = lean_ctor_get(x_7, 0); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_1); +x_9 = lean_ctor_get(x_7, 1); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_ctor_get(x_5, 1); +lean_inc(x_10); +lean_dec(x_5); +x_11 = l_Lake_MTime_checkUpToDate___rarg(x_2, x_3, x_10, x_9); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; uint64_t x_14; lean_object* x_15; +lean_dec(x_2); +x_12 = lean_ctor_get(x_7, 1); +lean_inc(x_12); +lean_dec(x_7); +x_13 = lean_ctor_get(x_8, 0); +lean_inc(x_13); +lean_dec(x_8); +x_14 = lean_unbox_uint64(x_13); +lean_dec(x_13); +x_15 = l_Lake_BuildTrace_checkAgainstHash___rarg(x_1, x_3, x_14, x_5, x_12); +return x_15; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstFile(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_BuildTrace_checkAgainstFile___rarg___boxed), 6, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_checkAgainstFile___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_BuildTrace_checkAgainstFile___rarg(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +return x_7; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildTrace_writeToFile(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +lean_inc(x_1); +x_4 = l_Lake_createParentDirs(x_1, x_3); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; lean_object* x_6; uint64_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_5 = lean_ctor_get(x_4, 1); +lean_inc(x_5); +lean_dec(x_4); +x_6 = lean_ctor_get(x_2, 0); +lean_inc(x_6); +lean_dec(x_2); +x_7 = lean_unbox_uint64(x_6); +lean_dec(x_6); +x_8 = lean_uint64_to_nat(x_7); +x_9 = l___private_Init_Data_Repr_0__Nat_reprFast(x_8); +x_10 = l_IO_FS_writeFile(x_1, x_9, x_5); +lean_dec(x_9); +lean_dec(x_1); +return x_10; +} +else +{ +uint8_t x_11; +lean_dec(x_2); +lean_dec(x_1); +x_11 = !lean_is_exclusive(x_4); +if (x_11 == 0) +{ +return x_4; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_4, 0); +x_13 = lean_ctor_get(x_4, 1); +lean_inc(x_13); +lean_inc(x_12); +lean_dec(x_4); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_12); +lean_ctor_set(x_14, 1, x_13); +return x_14; +} +} +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Util_IO(uint8_t builtin, lean_object*); +lean_object* initialize_Lean_Data_Json(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_Build_Trace(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Util_IO(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lean_Data_Json(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_instCheckExistsFilePath___closed__1 = _init_l_Lake_instCheckExistsFilePath___closed__1(); +lean_mark_persistent(l_Lake_instCheckExistsFilePath___closed__1); +l_Lake_instCheckExistsFilePath = _init_l_Lake_instCheckExistsFilePath(); +lean_mark_persistent(l_Lake_instCheckExistsFilePath); +l_Lake_instBEqHash___closed__1 = _init_l_Lake_instBEqHash___closed__1(); +lean_mark_persistent(l_Lake_instBEqHash___closed__1); +l_Lake_instBEqHash = _init_l_Lake_instBEqHash(); +lean_mark_persistent(l_Lake_instBEqHash); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__1 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__1(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__1); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__2 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__2(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__2); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__3 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__3(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__3); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__4 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__4(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__4); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__5); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__6 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__6(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__6); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__7 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__7(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__7); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__8 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__8(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__8); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__9 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__9(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__9); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__10 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__10(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__10); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__11 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__11(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__11); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__12 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__12(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__12); +l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__13 = _init_l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__13(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprHash____x40_Lake_Build_Trace___hyg_617____closed__13); +l_Lake_instReprHash___closed__1 = _init_l_Lake_instReprHash___closed__1(); +lean_mark_persistent(l_Lake_instReprHash___closed__1); +l_Lake_instReprHash = _init_l_Lake_instReprHash(); +lean_mark_persistent(l_Lake_instReprHash); +l_Lake_Hash_nil = _init_l_Lake_Hash_nil(); +l_Lake_Hash_instNilTrace = _init_l_Lake_Hash_instNilTrace(); +l_Lake_Hash_instMixTrace___closed__1 = _init_l_Lake_Hash_instMixTrace___closed__1(); +lean_mark_persistent(l_Lake_Hash_instMixTrace___closed__1); +l_Lake_Hash_instMixTrace = _init_l_Lake_Hash_instMixTrace(); +lean_mark_persistent(l_Lake_Hash_instMixTrace); +l_Lake_Hash_instToString___closed__1 = _init_l_Lake_Hash_instToString___closed__1(); +lean_mark_persistent(l_Lake_Hash_instToString___closed__1); +l_Lake_Hash_instToString = _init_l_Lake_Hash_instToString(); +lean_mark_persistent(l_Lake_Hash_instToString); +l_Lake_Hash_instToJson___closed__1 = _init_l_Lake_Hash_instToJson___closed__1(); +lean_mark_persistent(l_Lake_Hash_instToJson___closed__1); +l_Lake_Hash_instToJson = _init_l_Lake_Hash_instToJson(); +lean_mark_persistent(l_Lake_Hash_instToJson); +l_Lake_Hash_fromJson_x3f___closed__1 = _init_l_Lake_Hash_fromJson_x3f___closed__1(); +lean_mark_persistent(l_Lake_Hash_fromJson_x3f___closed__1); +l_Lake_Hash_fromJson_x3f___closed__2 = _init_l_Lake_Hash_fromJson_x3f___closed__2(); +lean_mark_persistent(l_Lake_Hash_fromJson_x3f___closed__2); +l_Lake_Hash_fromJson_x3f___closed__3 = _init_l_Lake_Hash_fromJson_x3f___closed__3(); +lean_mark_persistent(l_Lake_Hash_fromJson_x3f___closed__3); +l_Lake_Hash_instFromJson___closed__1 = _init_l_Lake_Hash_instFromJson___closed__1(); +lean_mark_persistent(l_Lake_Hash_instFromJson___closed__1); +l_Lake_Hash_instFromJson = _init_l_Lake_Hash_instFromJson(); +lean_mark_persistent(l_Lake_Hash_instFromJson); +l_Lake_instComputeHashStringId___closed__1 = _init_l_Lake_instComputeHashStringId___closed__1(); +lean_mark_persistent(l_Lake_instComputeHashStringId___closed__1); +l_Lake_instComputeHashStringId = _init_l_Lake_instComputeHashStringId(); +lean_mark_persistent(l_Lake_instComputeHashStringId); +l_Lake_instComputeHashFilePathIO___closed__1 = _init_l_Lake_instComputeHashFilePathIO___closed__1(); +lean_mark_persistent(l_Lake_instComputeHashFilePathIO___closed__1); +l_Lake_instComputeHashFilePathIO = _init_l_Lake_instComputeHashFilePathIO(); +lean_mark_persistent(l_Lake_instComputeHashFilePathIO); +l_Lake_computeTextFileHash___closed__1 = _init_l_Lake_computeTextFileHash___closed__1(); +lean_mark_persistent(l_Lake_computeTextFileHash___closed__1); +l_Lake_computeArrayHash___rarg___boxed__const__1 = _init_l_Lake_computeArrayHash___rarg___boxed__const__1(); +lean_mark_persistent(l_Lake_computeArrayHash___rarg___boxed__const__1); +l_Lake_MTime_instOfNat___closed__1 = _init_l_Lake_MTime_instOfNat___closed__1(); +lean_mark_persistent(l_Lake_MTime_instOfNat___closed__1); +l_Lake_MTime_instOfNat___closed__2 = _init_l_Lake_MTime_instOfNat___closed__2(); +lean_mark_persistent(l_Lake_MTime_instOfNat___closed__2); +l_Lake_MTime_instOfNat = _init_l_Lake_MTime_instOfNat(); +lean_mark_persistent(l_Lake_MTime_instOfNat); +l_Lake_MTime_instBEq = _init_l_Lake_MTime_instBEq(); +lean_mark_persistent(l_Lake_MTime_instBEq); +l_Lake_MTime_instRepr = _init_l_Lake_MTime_instRepr(); +lean_mark_persistent(l_Lake_MTime_instRepr); +l_Lake_MTime_instOrd = _init_l_Lake_MTime_instOrd(); +lean_mark_persistent(l_Lake_MTime_instOrd); +l_Lake_MTime_instLT = _init_l_Lake_MTime_instLT(); +lean_mark_persistent(l_Lake_MTime_instLT); +l_Lake_MTime_instLE = _init_l_Lake_MTime_instLE(); +lean_mark_persistent(l_Lake_MTime_instLE); +l_Lake_MTime_instNilTrace = _init_l_Lake_MTime_instNilTrace(); +lean_mark_persistent(l_Lake_MTime_instNilTrace); +l_Lake_instGetMTimeFilePath___closed__1 = _init_l_Lake_instGetMTimeFilePath___closed__1(); +lean_mark_persistent(l_Lake_instGetMTimeFilePath___closed__1); +l_Lake_instGetMTimeFilePath = _init_l_Lake_instGetMTimeFilePath(); +lean_mark_persistent(l_Lake_instGetMTimeFilePath); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__1 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__1(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__1); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__2 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__2(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__2); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__3 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__3(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__3); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__4 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__4(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__4); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__5 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__5(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__5); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__6 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__6(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__6); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__7 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__7(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__7); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__8 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__8(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__8); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__9 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__9(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__9); +l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__10 = _init_l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__10(); +lean_mark_persistent(l___private_Lake_Build_Trace_0__Lake_reprBuildTrace____x40_Lake_Build_Trace___hyg_1324____closed__10); +l_Lake_instReprBuildTrace___closed__1 = _init_l_Lake_instReprBuildTrace___closed__1(); +lean_mark_persistent(l_Lake_instReprBuildTrace___closed__1); +l_Lake_instReprBuildTrace = _init_l_Lake_instReprBuildTrace(); +lean_mark_persistent(l_Lake_instReprBuildTrace); +l_Lake_BuildTrace_instCoeHash___closed__1 = _init_l_Lake_BuildTrace_instCoeHash___closed__1(); +lean_mark_persistent(l_Lake_BuildTrace_instCoeHash___closed__1); +l_Lake_BuildTrace_instCoeHash = _init_l_Lake_BuildTrace_instCoeHash(); +lean_mark_persistent(l_Lake_BuildTrace_instCoeHash); +l_Lake_BuildTrace_ofMTime___boxed__const__1 = _init_l_Lake_BuildTrace_ofMTime___boxed__const__1(); +lean_mark_persistent(l_Lake_BuildTrace_ofMTime___boxed__const__1); +l_Lake_BuildTrace_instCoeMTime___closed__1 = _init_l_Lake_BuildTrace_instCoeMTime___closed__1(); +lean_mark_persistent(l_Lake_BuildTrace_instCoeMTime___closed__1); +l_Lake_BuildTrace_instCoeMTime = _init_l_Lake_BuildTrace_instCoeMTime(); +lean_mark_persistent(l_Lake_BuildTrace_instCoeMTime); +l_Lake_BuildTrace_nil___closed__1___boxed__const__1 = _init_l_Lake_BuildTrace_nil___closed__1___boxed__const__1(); +lean_mark_persistent(l_Lake_BuildTrace_nil___closed__1___boxed__const__1); +l_Lake_BuildTrace_nil___closed__1 = _init_l_Lake_BuildTrace_nil___closed__1(); +lean_mark_persistent(l_Lake_BuildTrace_nil___closed__1); +l_Lake_BuildTrace_nil = _init_l_Lake_BuildTrace_nil(); +lean_mark_persistent(l_Lake_BuildTrace_nil); +l_Lake_BuildTrace_instNilTrace = _init_l_Lake_BuildTrace_instNilTrace(); +lean_mark_persistent(l_Lake_BuildTrace_instNilTrace); +l_Lake_BuildTrace_instMixTrace___closed__1 = _init_l_Lake_BuildTrace_instMixTrace___closed__1(); +lean_mark_persistent(l_Lake_BuildTrace_instMixTrace___closed__1); +l_Lake_BuildTrace_instMixTrace = _init_l_Lake_BuildTrace_instMixTrace(); +lean_mark_persistent(l_Lake_BuildTrace_instMixTrace); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/CLI.c b/stage0/stdlib/Lake/CLI.c new file mode 100644 index 0000000000..7728262201 --- /dev/null +++ b/stage0/stdlib/Lake/CLI.c @@ -0,0 +1,33 @@ +// Lean compiler output +// Module: Lake.CLI +// Imports: Init Lake.CLI.Main +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_CLI_Main(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_CLI(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_CLI_Main(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/CLI/Actions.c b/stage0/stdlib/Lake/CLI/Actions.c new file mode 100644 index 0000000000..6ea87d40da --- /dev/null +++ b/stage0/stdlib/Lake/CLI/Actions.c @@ -0,0 +1,3210 @@ +// Lean compiler output +// Module: Lake.CLI.Actions +// Imports: Init Lake.Build.Run Lake.Build.Targets Lake.CLI.Build +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_resolveDriver___closed__3; +uint32_t lean_string_utf8_get(lean_object*, lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +static lean_object* l_Lake_Package_uploadRelease___closed__9; +lean_object* lean_array_data(lean_object*); +lean_object* l_System_FilePath_join(lean_object*, lean_object*); +static lean_object* l_Lake_Package_uploadRelease___closed__10; +static lean_object* l_Lake_Package_pack___closed__3; +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +lean_object* lean_array_push(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_test___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_pack___closed__1; +static lean_object* l_Lake_Package_uploadRelease___closed__3; +LEAN_EXPORT lean_object* l_Lake_Package_lint(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_String_splitAux___at_Lake_Package_resolveDriver___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_uploadRelease___closed__1; +static lean_object* l_Lake_exe___closed__2; +lean_object* l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(lean_object*, lean_object*); +lean_object* l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(lean_object*, lean_object*); +static lean_object* l_Lake_Package_resolveDriver___closed__2; +static lean_object* l_Lake_Package_test___closed__3; +static lean_object* l_Lake_exe___closed__4; +static lean_object* l_Lake_Package_lint___closed__2; +LEAN_EXPORT lean_object* l_Lake_Package_resolveDriver___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_process_child_wait(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Workspace_augmentedEnvVars(lean_object*); +lean_object* l_List_appendTR___rarg(lean_object*, lean_object*); +uint8_t l_String_isEmpty(lean_object*); +static lean_object* l_Lake_Package_test___lambda__1___closed__1; +static lean_object* l_Lake_Package_uploadRelease___closed__8; +static lean_object* l_Lake_Package_lint___closed__1; +static lean_object* l_Lake_Package_resolveDriver___closed__8; +lean_object* lean_string_utf8_next(lean_object*, lean_object*); +static lean_object* l_Lake_exe___closed__1; +static lean_object* l_Lake_exe___closed__3; +static lean_object* l_Lake_Package_uploadRelease___closed__5; +static lean_object* l_Lake_Package_unpack___closed__1; +static lean_object* l_Lake_Package_uploadRelease___closed__11; +static lean_object* l_Lake_Package_uploadRelease___closed__4; +LEAN_EXPORT lean_object* l_Lake_Package_unpack(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_pack(lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_List_isEmpty___rarg(lean_object*); +lean_object* l_Lake_CliError_toString(lean_object*); +lean_object* lean_array_to_list(lean_object*, lean_object*); +static lean_object* l_Lake_Package_resolveDriver___closed__5; +uint8_t lean_string_utf8_at_end(lean_object*, lean_object*); +lean_object* lean_io_process_spawn(lean_object*, lean_object*); +static lean_object* l_Lake_Package_test___closed__2; +static lean_object* l_Lake_Package_test___closed__1; +LEAN_EXPORT lean_object* l_Lake_env(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_test(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_resolveDriver___closed__1; +LEAN_EXPORT lean_object* l_Lake_Package_uploadRelease___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +extern lean_object* l_Lake_defaultLakeDir; +lean_object* l_Lake_untar(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_Package_uploadRelease___closed__2; +lean_object* l_Lake_Workspace_findLeanExe_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_uploadRelease(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_env___closed__1; +lean_object* l_Lake_LeanExe_fetch(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_resolveDriver___closed__6; +uint8_t lean_uint32_dec_eq(uint32_t, uint32_t); +LEAN_EXPORT lean_object* l_Lake_Package_resolveDriver(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_tar(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_resolveLibTarget(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Script_run(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_test___lambda__1___boxed__const__1; +lean_object* l_String_toName(lean_object*); +lean_object* l_Lake_Workspace_runFetchM___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_uploadRelease___lambda__1___closed__1; +static lean_object* l_Lake_Package_uploadRelease___closed__6; +static lean_object* l_Lake_Package_resolveDriver___closed__4; +lean_object* l_Lake_proc(lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* l_List_reverse___rarg(lean_object*); +LEAN_EXPORT lean_object* l_String_split___at_Lake_Package_resolveDriver___spec__1(lean_object*); +lean_object* l_Lean_RBNode_find___at_Lake_Package_findLeanLib_x3f___spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_Package_uploadRelease___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_Package_pack___closed__2; +lean_object* l_List_redLength___rarg(lean_object*); +static lean_object* l_Lake_Package_resolveDriver___closed__7; +static lean_object* l_Lake_Package_uploadRelease___closed__12; +lean_object* lean_string_append(lean_object*, lean_object*); +lean_object* l_Lake_buildSpecs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_String_splitAux___at_Lake_Package_resolveDriver___spec__2(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_io_wait(lean_object*, lean_object*); +lean_object* l_Lean_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_String_split___at_Lake_Package_resolveDriver___spec__1___boxed(lean_object*); +static lean_object* l_Lake_Package_uploadRelease___closed__7; +LEAN_EXPORT lean_object* l_Lake_Package_test___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_exe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_List_toArrayAux___rarg(lean_object*, lean_object*); +uint8_t l_Array_isEmpty___rarg(lean_object*); +static lean_object* _init_l_Lake_env___closed__1() { +_start: +{ +uint8_t x_1; lean_object* x_2; +x_1 = 1; +x_2 = lean_alloc_ctor(0, 0, 3); +lean_ctor_set_uint8(x_2, 0, x_1); +lean_ctor_set_uint8(x_2, 1, x_1); +lean_ctor_set_uint8(x_2, 2, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_env(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; lean_object* x_10; +x_5 = l_Lake_Workspace_augmentedEnvVars(x_3); +x_6 = lean_box(0); +x_7 = l_Lake_env___closed__1; +x_8 = 0; +x_9 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_9, 0, x_7); +lean_ctor_set(x_9, 1, x_1); +lean_ctor_set(x_9, 2, x_2); +lean_ctor_set(x_9, 3, x_6); +lean_ctor_set(x_9, 4, x_5); +lean_ctor_set_uint8(x_9, sizeof(void*)*5, x_8); +x_10 = lean_io_process_spawn(x_9, x_4); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_10, 0); +lean_inc(x_11); +x_12 = lean_ctor_get(x_10, 1); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_io_process_child_wait(x_7, x_11, x_12); +lean_dec(x_11); +return x_13; +} +else +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_10); +if (x_14 == 0) +{ +return x_10; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_10, 0); +x_16 = lean_ctor_get(x_10, 1); +lean_inc(x_16); +lean_inc(x_15); +lean_dec(x_10); +x_17 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_16); +return x_17; +} +} +} +} +static lean_object* _init_l_Lake_exe___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown executable `", 20); +return x_1; +} +} +static lean_object* _init_l_Lake_exe___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("`", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_exe___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("build failed", 12); +return x_1; +} +} +static lean_object* _init_l_Lake_exe___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_exe___closed__3; +x_2 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_exe(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Workspace_findLeanExe_x3f(x_1, x_4); +if (lean_obj_tag(x_6) == 0) +{ +uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_7 = 1; +x_8 = l_Lean_Name_toString(x_1, x_7); +x_9 = l_Lake_exe___closed__1; +x_10 = lean_string_append(x_9, x_8); +lean_dec(x_8); +x_11 = l_Lake_exe___closed__2; +x_12 = lean_string_append(x_10, x_11); +x_13 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_13, 0, x_12); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_5); +return x_14; +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +lean_dec(x_1); +x_15 = lean_ctor_get(x_6, 0); +lean_inc(x_15); +lean_dec(x_6); +x_16 = lean_alloc_closure((void*)(l_Lake_LeanExe_fetch), 7, 1); +lean_closure_set(x_16, 0, x_15); +lean_inc(x_4); +x_17 = l_Lake_Workspace_runFetchM___rarg(x_4, x_16, x_3, x_5); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_18 = lean_ctor_get(x_17, 0); +lean_inc(x_18); +x_19 = lean_ctor_get(x_17, 1); +lean_inc(x_19); +lean_dec(x_17); +x_20 = lean_ctor_get(x_18, 0); +lean_inc(x_20); +lean_dec(x_18); +x_21 = lean_io_wait(x_20, x_19); +x_22 = lean_ctor_get(x_21, 0); +lean_inc(x_22); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_21, 1); +lean_inc(x_23); +lean_dec(x_21); +x_24 = lean_ctor_get(x_22, 0); +lean_inc(x_24); +lean_dec(x_22); +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +lean_dec(x_24); +x_26 = l_Lake_env(x_25, x_2, x_4, x_23); +return x_26; +} +else +{ +uint8_t x_27; +lean_dec(x_22); +lean_dec(x_4); +lean_dec(x_2); +x_27 = !lean_is_exclusive(x_21); +if (x_27 == 0) +{ +lean_object* x_28; lean_object* x_29; +x_28 = lean_ctor_get(x_21, 0); +lean_dec(x_28); +x_29 = l_Lake_exe___closed__4; +lean_ctor_set_tag(x_21, 1); +lean_ctor_set(x_21, 0, x_29); +return x_21; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_30 = lean_ctor_get(x_21, 1); +lean_inc(x_30); +lean_dec(x_21); +x_31 = l_Lake_exe___closed__4; +x_32 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_30); +return x_32; +} +} +} +else +{ +uint8_t x_33; +lean_dec(x_4); +lean_dec(x_2); +x_33 = !lean_is_exclusive(x_17); +if (x_33 == 0) +{ +return x_17; +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +x_34 = lean_ctor_get(x_17, 0); +x_35 = lean_ctor_get(x_17, 1); +lean_inc(x_35); +lean_inc(x_34); +lean_dec(x_17); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set(x_36, 1, x_35); +return x_36; +} +} +} +} +} +static lean_object* _init_l_Lake_Package_pack___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("packing ", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_pack___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_pack___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_pack(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; +x_5 = l_Lake_Package_pack___closed__1; +x_6 = lean_string_append(x_5, x_2); +x_7 = l_Lake_Package_pack___closed__2; +x_8 = lean_string_append(x_6, x_7); +x_9 = 1; +x_10 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_10, 0, x_8); +lean_ctor_set_uint8(x_10, sizeof(void*)*1, x_9); +x_11 = lean_array_push(x_3, x_10); +x_12 = lean_ctor_get(x_1, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_1, 2); +lean_inc(x_13); +lean_dec(x_1); +x_14 = lean_ctor_get(x_13, 8); +lean_inc(x_14); +lean_dec(x_13); +x_15 = l_System_FilePath_join(x_12, x_14); +x_16 = 1; +x_17 = l_Lake_Package_pack___closed__3; +x_18 = l_Lake_tar(x_15, x_2, x_16, x_17, x_11, x_4); +return x_18; +} +} +static lean_object* _init_l_Lake_Package_unpack___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unpacking ", 10); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_unpack(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; +x_5 = l_Lake_Package_unpack___closed__1; +x_6 = lean_string_append(x_5, x_2); +x_7 = l_Lake_Package_pack___closed__2; +x_8 = lean_string_append(x_6, x_7); +x_9 = 1; +x_10 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_10, 0, x_8); +lean_ctor_set_uint8(x_10, sizeof(void*)*1, x_9); +x_11 = lean_array_push(x_3, x_10); +x_12 = lean_ctor_get(x_1, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_1, 2); +lean_inc(x_13); +lean_dec(x_1); +x_14 = lean_ctor_get(x_13, 8); +lean_inc(x_14); +lean_dec(x_13); +x_15 = l_System_FilePath_join(x_12, x_14); +x_16 = 1; +x_17 = l_Lake_untar(x_2, x_15, x_16, x_11, x_4); +return x_17; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("gh", 2); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_uploadRelease___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; lean_object* x_10; lean_object* x_11; +x_5 = lean_box(0); +x_6 = l_Lake_env___closed__1; +x_7 = l_Lake_Package_uploadRelease___lambda__1___closed__1; +x_8 = l_Lake_Package_pack___closed__3; +x_9 = 0; +x_10 = lean_alloc_ctor(0, 5, 1); +lean_ctor_set(x_10, 0, x_6); +lean_ctor_set(x_10, 1, x_7); +lean_ctor_set(x_10, 2, x_1); +lean_ctor_set(x_10, 3, x_5); +lean_ctor_set(x_10, 4, x_8); +lean_ctor_set_uint8(x_10, sizeof(void*)*5, x_9); +x_11 = l_Lake_proc(x_10, x_9, x_3, x_4); +return x_11; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("uploading ", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(5u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("release", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__5() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_uploadRelease___closed__3; +x_2 = l_Lake_Package_uploadRelease___closed__4; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("upload", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_uploadRelease___closed__5; +x_2 = l_Lake_Package_uploadRelease___closed__6; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("--clobber", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_Package_uploadRelease___lambda__1___boxed), 4, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(2u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__11() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("-R", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_uploadRelease___closed__12() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l_Lake_Package_uploadRelease___closed__10; +x_2 = l_Lake_Package_uploadRelease___closed__11; +x_3 = lean_array_push(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_uploadRelease(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_5 = lean_ctor_get(x_1, 0); +lean_inc(x_5); +x_6 = l_Lake_defaultLakeDir; +x_7 = l_System_FilePath_join(x_5, x_6); +x_8 = lean_ctor_get(x_1, 2); +lean_inc(x_8); +x_9 = lean_ctor_get(x_8, 16); +lean_inc(x_9); +lean_inc(x_9); +x_10 = l_System_FilePath_join(x_7, x_9); +lean_inc(x_10); +x_11 = l_Lake_Package_pack(x_1, x_10, x_3, x_4); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_13 = lean_ctor_get(x_11, 1); +lean_inc(x_13); +lean_dec(x_11); +x_14 = lean_ctor_get(x_12, 1); +lean_inc(x_14); +lean_dec(x_12); +x_15 = l_Lake_Package_uploadRelease___closed__1; +x_16 = lean_string_append(x_15, x_2); +x_17 = l_Lake_Package_uploadRelease___closed__2; +x_18 = lean_string_append(x_16, x_17); +x_19 = lean_string_append(x_18, x_9); +lean_dec(x_9); +x_20 = l_Lake_Package_pack___closed__2; +x_21 = lean_string_append(x_19, x_20); +x_22 = 1; +x_23 = lean_alloc_ctor(0, 1, 1); +lean_ctor_set(x_23, 0, x_21); +lean_ctor_set_uint8(x_23, sizeof(void*)*1, x_22); +x_24 = lean_array_push(x_14, x_23); +x_25 = l_Lake_Package_uploadRelease___closed__7; +x_26 = lean_array_push(x_25, x_2); +x_27 = lean_array_push(x_26, x_10); +x_28 = l_Lake_Package_uploadRelease___closed__8; +x_29 = lean_array_push(x_27, x_28); +x_30 = l_Lake_Package_uploadRelease___closed__9; +x_31 = lean_ctor_get(x_8, 14); +lean_inc(x_31); +if (lean_obj_tag(x_31) == 0) +{ +lean_object* x_32; +x_32 = lean_ctor_get(x_8, 13); +lean_inc(x_32); +lean_dec(x_8); +if (lean_obj_tag(x_32) == 0) +{ +lean_object* x_33; lean_object* x_34; +x_33 = lean_box(0); +x_34 = lean_apply_4(x_30, x_29, x_33, x_24, x_13); +return x_34; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_35 = lean_ctor_get(x_32, 0); +lean_inc(x_35); +lean_dec(x_32); +x_36 = l_Lake_Package_uploadRelease___closed__12; +x_37 = lean_array_push(x_36, x_35); +x_38 = l_Array_append___rarg(x_29, x_37); +lean_dec(x_37); +x_39 = lean_box(0); +x_40 = lean_apply_4(x_30, x_38, x_39, x_24, x_13); +return x_40; +} +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_dec(x_8); +x_41 = lean_ctor_get(x_31, 0); +lean_inc(x_41); +lean_dec(x_31); +x_42 = l_Lake_Package_uploadRelease___closed__12; +x_43 = lean_array_push(x_42, x_41); +x_44 = l_Array_append___rarg(x_29, x_43); +lean_dec(x_43); +x_45 = lean_box(0); +x_46 = lean_apply_4(x_30, x_44, x_45, x_24, x_13); +return x_46; +} +} +else +{ +uint8_t x_47; +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_2); +x_47 = !lean_is_exclusive(x_11); +if (x_47 == 0) +{ +lean_object* x_48; uint8_t x_49; +x_48 = lean_ctor_get(x_11, 0); +lean_dec(x_48); +x_49 = !lean_is_exclusive(x_12); +if (x_49 == 0) +{ +return x_11; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_12, 0); +x_51 = lean_ctor_get(x_12, 1); +lean_inc(x_51); +lean_inc(x_50); +lean_dec(x_12); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_50); +lean_ctor_set(x_52, 1, x_51); +lean_ctor_set(x_11, 0, x_52); +return x_11; +} +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_53 = lean_ctor_get(x_11, 1); +lean_inc(x_53); +lean_dec(x_11); +x_54 = lean_ctor_get(x_12, 0); +lean_inc(x_54); +x_55 = lean_ctor_get(x_12, 1); +lean_inc(x_55); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_56 = x_12; +} else { + lean_dec_ref(x_12); + x_56 = lean_box(0); +} +if (lean_is_scalar(x_56)) { + x_57 = lean_alloc_ctor(1, 2, 0); +} else { + x_57 = x_56; +} +lean_ctor_set(x_57, 0, x_54); +lean_ctor_set(x_57, 1, x_55); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_53); +return x_58; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_uploadRelease___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Package_uploadRelease___lambda__1(x_1, x_2, x_3, x_4); +lean_dec(x_2); +return x_5; +} +} +LEAN_EXPORT lean_object* l_String_splitAux___at_Lake_Package_resolveDriver___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = lean_string_utf8_at_end(x_1, x_3); +if (x_5 == 0) +{ +uint32_t x_6; uint32_t x_7; uint8_t x_8; +x_6 = lean_string_utf8_get(x_1, x_3); +x_7 = 47; +x_8 = lean_uint32_dec_eq(x_6, x_7); +if (x_8 == 0) +{ +lean_object* x_9; +x_9 = lean_string_utf8_next(x_1, x_3); +lean_dec(x_3); +x_3 = x_9; +goto _start; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_string_utf8_next(x_1, x_3); +x_12 = lean_string_utf8_extract(x_1, x_2, x_3); +lean_dec(x_3); +lean_dec(x_2); +x_13 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_4); +lean_inc(x_11); +x_2 = x_11; +x_3 = x_11; +x_4 = x_13; +goto _start; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_string_utf8_extract(x_1, x_2, x_3); +lean_dec(x_3); +lean_dec(x_2); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_4); +x_17 = l_List_reverse___rarg(x_16); +return x_17; +} +} +} +LEAN_EXPORT lean_object* l_String_split___at_Lake_Package_resolveDriver___spec__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_2 = lean_box(0); +x_3 = lean_unsigned_to_nat(0u); +x_4 = l_String_splitAux___at_Lake_Package_resolveDriver___spec__2(x_1, x_3, x_3, x_2); +return x_4; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": invalid ", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" driver '", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' (too many '/')", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": unknown ", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" driver package '", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("'", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": no ", 5); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_resolveDriver___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" driver configured", 18); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_resolveDriver(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; uint8_t x_8; lean_object* x_9; uint8_t x_10; +x_6 = lean_ctor_get(x_1, 2); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 2); +lean_inc(x_7); +lean_dec(x_6); +x_8 = 0; +x_9 = l_Lean_Name_toString(x_7, x_8); +x_10 = l_String_isEmpty(x_3); +if (x_10 == 0) +{ +lean_object* x_11; +x_11 = l_String_split___at_Lake_Package_resolveDriver___spec__1(x_3); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +lean_dec(x_1); +x_12 = l_Lake_Package_pack___closed__2; +x_13 = lean_string_append(x_12, x_9); +lean_dec(x_9); +x_14 = l_Lake_Package_resolveDriver___closed__1; +x_15 = lean_string_append(x_13, x_14); +x_16 = lean_string_append(x_15, x_2); +x_17 = l_Lake_Package_resolveDriver___closed__2; +x_18 = lean_string_append(x_16, x_17); +x_19 = lean_string_append(x_18, x_3); +x_20 = l_Lake_Package_resolveDriver___closed__3; +x_21 = lean_string_append(x_19, x_20); +x_22 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_22, 0, x_21); +x_23 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_23, 0, x_22); +lean_ctor_set(x_23, 1, x_5); +return x_23; +} +else +{ +lean_object* x_24; +x_24 = lean_ctor_get(x_11, 1); +lean_inc(x_24); +if (lean_obj_tag(x_24) == 0) +{ +uint8_t x_25; +lean_dec(x_9); +x_25 = !lean_is_exclusive(x_11); +if (x_25 == 0) +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_26 = lean_ctor_get(x_11, 0); +x_27 = lean_ctor_get(x_11, 1); +lean_dec(x_27); +lean_ctor_set_tag(x_11, 0); +lean_ctor_set(x_11, 1, x_26); +lean_ctor_set(x_11, 0, x_1); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_11); +lean_ctor_set(x_28, 1, x_5); +return x_28; +} +else +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_11, 0); +lean_inc(x_29); +lean_dec(x_11); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_1); +lean_ctor_set(x_30, 1, x_29); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_5); +return x_31; +} +} +else +{ +lean_object* x_32; +lean_dec(x_1); +x_32 = lean_ctor_get(x_24, 1); +lean_inc(x_32); +if (lean_obj_tag(x_32) == 0) +{ +uint8_t x_33; +x_33 = !lean_is_exclusive(x_11); +if (x_33 == 0) +{ +lean_object* x_34; lean_object* x_35; uint8_t x_36; +x_34 = lean_ctor_get(x_11, 0); +x_35 = lean_ctor_get(x_11, 1); +lean_dec(x_35); +x_36 = !lean_is_exclusive(x_24); +if (x_36 == 0) +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_37 = lean_ctor_get(x_24, 0); +x_38 = lean_ctor_get(x_24, 1); +lean_dec(x_38); +lean_inc(x_34); +x_39 = l_String_toName(x_34); +x_40 = lean_ctor_get(x_4, 3); +x_41 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(x_40, x_39); +lean_dec(x_39); +if (lean_obj_tag(x_41) == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +lean_dec(x_37); +lean_free_object(x_11); +x_42 = l_Lake_Package_pack___closed__2; +x_43 = lean_string_append(x_42, x_9); +lean_dec(x_9); +x_44 = l_Lake_Package_resolveDriver___closed__4; +x_45 = lean_string_append(x_43, x_44); +x_46 = lean_string_append(x_45, x_2); +x_47 = l_Lake_Package_resolveDriver___closed__5; +x_48 = lean_string_append(x_46, x_47); +x_49 = lean_string_append(x_48, x_34); +lean_dec(x_34); +x_50 = l_Lake_Package_resolveDriver___closed__6; +x_51 = lean_string_append(x_49, x_50); +x_52 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_24, 1, x_5); +lean_ctor_set(x_24, 0, x_52); +return x_24; +} +else +{ +lean_object* x_53; +lean_dec(x_34); +lean_dec(x_9); +x_53 = lean_ctor_get(x_41, 0); +lean_inc(x_53); +lean_dec(x_41); +lean_ctor_set_tag(x_24, 0); +lean_ctor_set(x_24, 1, x_37); +lean_ctor_set(x_24, 0, x_53); +lean_ctor_set_tag(x_11, 0); +lean_ctor_set(x_11, 1, x_5); +lean_ctor_set(x_11, 0, x_24); +return x_11; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_54 = lean_ctor_get(x_24, 0); +lean_inc(x_54); +lean_dec(x_24); +lean_inc(x_34); +x_55 = l_String_toName(x_34); +x_56 = lean_ctor_get(x_4, 3); +x_57 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(x_56, x_55); +lean_dec(x_55); +if (lean_obj_tag(x_57) == 0) +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_54); +lean_free_object(x_11); +x_58 = l_Lake_Package_pack___closed__2; +x_59 = lean_string_append(x_58, x_9); +lean_dec(x_9); +x_60 = l_Lake_Package_resolveDriver___closed__4; +x_61 = lean_string_append(x_59, x_60); +x_62 = lean_string_append(x_61, x_2); +x_63 = l_Lake_Package_resolveDriver___closed__5; +x_64 = lean_string_append(x_62, x_63); +x_65 = lean_string_append(x_64, x_34); +lean_dec(x_34); +x_66 = l_Lake_Package_resolveDriver___closed__6; +x_67 = lean_string_append(x_65, x_66); +x_68 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_68, 0, x_67); +x_69 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_69, 0, x_68); +lean_ctor_set(x_69, 1, x_5); +return x_69; +} +else +{ +lean_object* x_70; lean_object* x_71; +lean_dec(x_34); +lean_dec(x_9); +x_70 = lean_ctor_get(x_57, 0); +lean_inc(x_70); +lean_dec(x_57); +x_71 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_71, 0, x_70); +lean_ctor_set(x_71, 1, x_54); +lean_ctor_set_tag(x_11, 0); +lean_ctor_set(x_11, 1, x_5); +lean_ctor_set(x_11, 0, x_71); +return x_11; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_72 = lean_ctor_get(x_11, 0); +lean_inc(x_72); +lean_dec(x_11); +x_73 = lean_ctor_get(x_24, 0); +lean_inc(x_73); +if (lean_is_exclusive(x_24)) { + lean_ctor_release(x_24, 0); + lean_ctor_release(x_24, 1); + x_74 = x_24; +} else { + lean_dec_ref(x_24); + x_74 = lean_box(0); +} +lean_inc(x_72); +x_75 = l_String_toName(x_72); +x_76 = lean_ctor_get(x_4, 3); +x_77 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(x_76, x_75); +lean_dec(x_75); +if (lean_obj_tag(x_77) == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +lean_dec(x_73); +x_78 = l_Lake_Package_pack___closed__2; +x_79 = lean_string_append(x_78, x_9); +lean_dec(x_9); +x_80 = l_Lake_Package_resolveDriver___closed__4; +x_81 = lean_string_append(x_79, x_80); +x_82 = lean_string_append(x_81, x_2); +x_83 = l_Lake_Package_resolveDriver___closed__5; +x_84 = lean_string_append(x_82, x_83); +x_85 = lean_string_append(x_84, x_72); +lean_dec(x_72); +x_86 = l_Lake_Package_resolveDriver___closed__6; +x_87 = lean_string_append(x_85, x_86); +x_88 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_88, 0, x_87); +if (lean_is_scalar(x_74)) { + x_89 = lean_alloc_ctor(1, 2, 0); +} else { + x_89 = x_74; +} +lean_ctor_set(x_89, 0, x_88); +lean_ctor_set(x_89, 1, x_5); +return x_89; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +lean_dec(x_72); +lean_dec(x_9); +x_90 = lean_ctor_get(x_77, 0); +lean_inc(x_90); +lean_dec(x_77); +if (lean_is_scalar(x_74)) { + x_91 = lean_alloc_ctor(0, 2, 0); +} else { + x_91 = x_74; + lean_ctor_set_tag(x_91, 0); +} +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_73); +x_92 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_92, 0, x_91); +lean_ctor_set(x_92, 1, x_5); +return x_92; +} +} +} +else +{ +uint8_t x_93; +lean_dec(x_24); +lean_dec(x_11); +x_93 = !lean_is_exclusive(x_32); +if (x_93 == 0) +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_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; +x_94 = lean_ctor_get(x_32, 1); +lean_dec(x_94); +x_95 = lean_ctor_get(x_32, 0); +lean_dec(x_95); +x_96 = l_Lake_Package_pack___closed__2; +x_97 = lean_string_append(x_96, x_9); +lean_dec(x_9); +x_98 = l_Lake_Package_resolveDriver___closed__1; +x_99 = lean_string_append(x_97, x_98); +x_100 = lean_string_append(x_99, x_2); +x_101 = l_Lake_Package_resolveDriver___closed__2; +x_102 = lean_string_append(x_100, x_101); +x_103 = lean_string_append(x_102, x_3); +x_104 = l_Lake_Package_resolveDriver___closed__3; +x_105 = lean_string_append(x_103, x_104); +x_106 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_106, 0, x_105); +lean_ctor_set(x_32, 1, x_5); +lean_ctor_set(x_32, 0, x_106); +return x_32; +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; +lean_dec(x_32); +x_107 = l_Lake_Package_pack___closed__2; +x_108 = lean_string_append(x_107, x_9); +lean_dec(x_9); +x_109 = l_Lake_Package_resolveDriver___closed__1; +x_110 = lean_string_append(x_108, x_109); +x_111 = lean_string_append(x_110, x_2); +x_112 = l_Lake_Package_resolveDriver___closed__2; +x_113 = lean_string_append(x_111, x_112); +x_114 = lean_string_append(x_113, x_3); +x_115 = l_Lake_Package_resolveDriver___closed__3; +x_116 = lean_string_append(x_114, x_115); +x_117 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_117, 0, x_116); +x_118 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_118, 0, x_117); +lean_ctor_set(x_118, 1, x_5); +return x_118; +} +} +} +} +} +else +{ +lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +lean_dec(x_1); +x_119 = l_Lake_Package_pack___closed__2; +x_120 = lean_string_append(x_119, x_9); +lean_dec(x_9); +x_121 = l_Lake_Package_resolveDriver___closed__7; +x_122 = lean_string_append(x_120, x_121); +x_123 = lean_string_append(x_122, x_2); +x_124 = l_Lake_Package_resolveDriver___closed__8; +x_125 = lean_string_append(x_123, x_124); +x_126 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_126, 0, x_125); +x_127 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_127, 0, x_126); +lean_ctor_set(x_127, 1, x_5); +return x_127; +} +} +} +LEAN_EXPORT lean_object* l_String_splitAux___at_Lake_Package_resolveDriver___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_String_splitAux___at_Lake_Package_resolveDriver___spec__2(x_1, x_2, x_3, x_4); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_String_split___at_Lake_Package_resolveDriver___spec__1___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_String_split___at_Lake_Package_resolveDriver___spec__1(x_1); +lean_dec(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_resolveDriver___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = l_Lake_Package_resolveDriver(x_1, x_2, x_3, x_4, x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_6; +} +} +static lean_object* _init_l_Lake_Package_test___lambda__1___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": invalid test driver: ", 23); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_test___lambda__1___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 0; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_test___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; lean_object* x_8; +x_7 = lean_box(0); +x_8 = l_Lake_resolveLibTarget(x_5, x_1, x_7); +if (lean_obj_tag(x_8) == 0) +{ +uint8_t x_9; +lean_dec(x_5); +lean_dec(x_3); +x_9 = !lean_is_exclusive(x_8); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +x_10 = lean_ctor_get(x_8, 0); +x_11 = l_Lake_Package_pack___closed__2; +x_12 = lean_string_append(x_11, x_2); +x_13 = l_Lake_Package_test___lambda__1___closed__1; +x_14 = lean_string_append(x_12, x_13); +x_15 = l_Lake_CliError_toString(x_10); +x_16 = lean_string_append(x_14, x_15); +lean_dec(x_15); +x_17 = lean_string_append(x_16, x_11); +lean_ctor_set_tag(x_8, 18); +lean_ctor_set(x_8, 0, x_17); +x_18 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_18, 0, x_8); +lean_ctor_set(x_18, 1, x_6); +return x_18; +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_19 = lean_ctor_get(x_8, 0); +lean_inc(x_19); +lean_dec(x_8); +x_20 = l_Lake_Package_pack___closed__2; +x_21 = lean_string_append(x_20, x_2); +x_22 = l_Lake_Package_test___lambda__1___closed__1; +x_23 = lean_string_append(x_21, x_22); +x_24 = l_Lake_CliError_toString(x_19); +x_25 = lean_string_append(x_23, x_24); +lean_dec(x_24); +x_26 = lean_string_append(x_25, x_20); +x_27 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_27, 0, x_26); +x_28 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_6); +return x_28; +} +} +else +{ +lean_object* x_29; lean_object* x_30; uint8_t x_31; +x_29 = lean_ctor_get(x_8, 0); +lean_inc(x_29); +lean_dec(x_8); +x_30 = lean_alloc_closure((void*)(l_Lake_buildSpecs), 7, 1); +lean_closure_set(x_30, 0, x_29); +x_31 = !lean_is_exclusive(x_3); +if (x_31 == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_3, 0); +lean_dec(x_32); +x_33 = lean_box(0); +lean_ctor_set(x_3, 0, x_33); +x_34 = l_Lake_Workspace_runFetchM___rarg(x_5, x_30, x_3, x_6); +if (lean_obj_tag(x_34) == 0) +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_35 = lean_ctor_get(x_34, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_34, 1); +lean_inc(x_36); +lean_dec(x_34); +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = lean_io_wait(x_37, x_36); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +if (lean_obj_tag(x_39) == 0) +{ +uint8_t x_40; +lean_dec(x_39); +x_40 = !lean_is_exclusive(x_38); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_38, 0); +lean_dec(x_41); +x_42 = l_Lake_Package_test___lambda__1___boxed__const__1; +lean_ctor_set(x_38, 0, x_42); +return x_38; +} +else +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; +x_43 = lean_ctor_get(x_38, 1); +lean_inc(x_43); +lean_dec(x_38); +x_44 = l_Lake_Package_test___lambda__1___boxed__const__1; +x_45 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_45, 0, x_44); +lean_ctor_set(x_45, 1, x_43); +return x_45; +} +} +else +{ +uint8_t x_46; +lean_dec(x_39); +x_46 = !lean_is_exclusive(x_38); +if (x_46 == 0) +{ +lean_object* x_47; lean_object* x_48; +x_47 = lean_ctor_get(x_38, 0); +lean_dec(x_47); +x_48 = l_Lake_exe___closed__4; +lean_ctor_set_tag(x_38, 1); +lean_ctor_set(x_38, 0, x_48); +return x_38; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_38, 1); +lean_inc(x_49); +lean_dec(x_38); +x_50 = l_Lake_exe___closed__4; +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_49); +return x_51; +} +} +} +else +{ +uint8_t x_52; +x_52 = !lean_is_exclusive(x_34); +if (x_52 == 0) +{ +return x_34; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_53 = lean_ctor_get(x_34, 0); +x_54 = lean_ctor_get(x_34, 1); +lean_inc(x_54); +lean_inc(x_53); +lean_dec(x_34); +x_55 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +return x_55; +} +} +} +else +{ +uint8_t x_56; uint8_t x_57; uint8_t x_58; uint8_t x_59; uint8_t x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_56 = lean_ctor_get_uint8(x_3, sizeof(void*)*1); +x_57 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 1); +x_58 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 2); +x_59 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 3); +x_60 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 4); +x_61 = lean_ctor_get_uint8(x_3, sizeof(void*)*1 + 5); +lean_dec(x_3); +x_62 = lean_box(0); +x_63 = lean_alloc_ctor(0, 1, 6); +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set_uint8(x_63, sizeof(void*)*1, x_56); +lean_ctor_set_uint8(x_63, sizeof(void*)*1 + 1, x_57); +lean_ctor_set_uint8(x_63, sizeof(void*)*1 + 2, x_58); +lean_ctor_set_uint8(x_63, sizeof(void*)*1 + 3, x_59); +lean_ctor_set_uint8(x_63, sizeof(void*)*1 + 4, x_60); +lean_ctor_set_uint8(x_63, sizeof(void*)*1 + 5, x_61); +x_64 = l_Lake_Workspace_runFetchM___rarg(x_5, x_30, x_63, x_6); +if (lean_obj_tag(x_64) == 0) +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_65 = lean_ctor_get(x_64, 0); +lean_inc(x_65); +x_66 = lean_ctor_get(x_64, 1); +lean_inc(x_66); +lean_dec(x_64); +x_67 = lean_ctor_get(x_65, 0); +lean_inc(x_67); +lean_dec(x_65); +x_68 = lean_io_wait(x_67, x_66); +x_69 = lean_ctor_get(x_68, 0); +lean_inc(x_69); +if (lean_obj_tag(x_69) == 0) +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +lean_dec(x_69); +x_70 = lean_ctor_get(x_68, 1); +lean_inc(x_70); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_71 = x_68; +} else { + lean_dec_ref(x_68); + x_71 = lean_box(0); +} +x_72 = l_Lake_Package_test___lambda__1___boxed__const__1; +if (lean_is_scalar(x_71)) { + x_73 = lean_alloc_ctor(0, 2, 0); +} else { + x_73 = x_71; +} +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_70); +return x_73; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +lean_dec(x_69); +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_75 = x_68; +} else { + lean_dec_ref(x_68); + x_75 = lean_box(0); +} +x_76 = l_Lake_exe___closed__4; +if (lean_is_scalar(x_75)) { + x_77 = lean_alloc_ctor(1, 2, 0); +} else { + x_77 = x_75; + lean_ctor_set_tag(x_77, 1); +} +lean_ctor_set(x_77, 0, x_76); +lean_ctor_set(x_77, 1, x_74); +return x_77; +} +} +else +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_78 = lean_ctor_get(x_64, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_64, 1); +lean_inc(x_79); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_80 = x_64; +} else { + lean_dec_ref(x_64); + x_80 = lean_box(0); +} +if (lean_is_scalar(x_80)) { + x_81 = lean_alloc_ctor(1, 2, 0); +} else { + x_81 = x_80; +} +lean_ctor_set(x_81, 0, x_78); +lean_ctor_set(x_81, 1, x_79); +return x_81; +} +} +} +} +} +static lean_object* _init_l_Lake_Package_test___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("test", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_test___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": invalid test driver: unknown script, executable, or library '", 63); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_test___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": arguments cannot be passed to a library test driver", 53); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_test(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_1, 2); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 18); +lean_inc(x_7); +lean_dec(x_6); +x_8 = lean_ctor_get(x_1, 16); +lean_inc(x_8); +x_9 = l_Lake_Package_test___closed__1; +x_10 = l_Lake_Package_resolveDriver(x_1, x_9, x_8, x_4, x_5); +lean_dec(x_8); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_10, 0); +x_13 = !lean_is_exclusive(x_12); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_14 = lean_ctor_get(x_10, 1); +x_15 = lean_ctor_get(x_12, 0); +x_16 = lean_ctor_get(x_12, 1); +x_17 = lean_ctor_get(x_15, 2); +lean_inc(x_17); +x_18 = lean_ctor_get(x_17, 2); +lean_inc(x_18); +lean_dec(x_17); +x_19 = 0; +x_20 = l_Lean_Name_toString(x_18, x_19); +x_21 = lean_ctor_get(x_15, 13); +lean_inc(x_21); +lean_inc(x_16); +x_22 = l_String_toName(x_16); +x_23 = l_Lean_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_21, x_22); +lean_dec(x_21); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_24 = lean_ctor_get(x_15, 9); +lean_inc(x_24); +x_25 = lean_ctor_get(x_24, 0); +lean_inc(x_25); +lean_dec(x_24); +x_26 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_25, x_22); +lean_dec(x_25); +if (lean_obj_tag(x_26) == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_15, 8); +lean_inc(x_27); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +lean_dec(x_27); +x_29 = l_Lean_RBNode_find___at_Lake_Package_findLeanLib_x3f___spec__1(x_28, x_22); +lean_dec(x_22); +lean_dec(x_28); +if (lean_obj_tag(x_29) == 0) +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_free_object(x_12); +lean_dec(x_15); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_30 = l_Lake_Package_pack___closed__2; +x_31 = lean_string_append(x_30, x_20); +lean_dec(x_20); +x_32 = l_Lake_Package_test___closed__2; +x_33 = lean_string_append(x_31, x_32); +x_34 = lean_string_append(x_33, x_16); +lean_dec(x_16); +x_35 = l_Lake_Package_resolveDriver___closed__6; +x_36 = lean_string_append(x_34, x_35); +x_37 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_37, 0, x_36); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_37); +return x_10; +} +else +{ +uint8_t x_38; +lean_dec(x_16); +x_38 = !lean_is_exclusive(x_29); +if (x_38 == 0) +{ +lean_object* x_39; uint8_t x_40; +x_39 = lean_ctor_get(x_29, 0); +lean_ctor_set(x_12, 1, x_39); +x_40 = l_Array_isEmpty___rarg(x_7); +lean_dec(x_7); +if (x_40 == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_12); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_41 = l_Lake_Package_pack___closed__2; +x_42 = lean_string_append(x_41, x_20); +lean_dec(x_20); +x_43 = l_Lake_Package_test___closed__3; +x_44 = lean_string_append(x_42, x_43); +lean_ctor_set_tag(x_29, 18); +lean_ctor_set(x_29, 0, x_44); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_29); +return x_10; +} +else +{ +uint8_t x_45; +x_45 = l_List_isEmpty___rarg(x_2); +lean_dec(x_2); +if (x_45 == 0) +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +lean_dec(x_12); +lean_dec(x_4); +lean_dec(x_3); +x_46 = l_Lake_Package_pack___closed__2; +x_47 = lean_string_append(x_46, x_20); +lean_dec(x_20); +x_48 = l_Lake_Package_test___closed__3; +x_49 = lean_string_append(x_47, x_48); +lean_ctor_set_tag(x_29, 18); +lean_ctor_set(x_29, 0, x_49); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_29); +return x_10; +} +else +{ +lean_object* x_50; lean_object* x_51; +lean_free_object(x_29); +lean_free_object(x_10); +x_50 = lean_box(0); +x_51 = l_Lake_Package_test___lambda__1(x_12, x_20, x_3, x_50, x_4, x_14); +lean_dec(x_20); +return x_51; +} +} +} +else +{ +lean_object* x_52; uint8_t x_53; +x_52 = lean_ctor_get(x_29, 0); +lean_inc(x_52); +lean_dec(x_29); +lean_ctor_set(x_12, 1, x_52); +x_53 = l_Array_isEmpty___rarg(x_7); +lean_dec(x_7); +if (x_53 == 0) +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_12); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_54 = l_Lake_Package_pack___closed__2; +x_55 = lean_string_append(x_54, x_20); +lean_dec(x_20); +x_56 = l_Lake_Package_test___closed__3; +x_57 = lean_string_append(x_55, x_56); +x_58 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_58); +return x_10; +} +else +{ +uint8_t x_59; +x_59 = l_List_isEmpty___rarg(x_2); +lean_dec(x_2); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_12); +lean_dec(x_4); +lean_dec(x_3); +x_60 = l_Lake_Package_pack___closed__2; +x_61 = lean_string_append(x_60, x_20); +lean_dec(x_20); +x_62 = l_Lake_Package_test___closed__3; +x_63 = lean_string_append(x_61, x_62); +x_64 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_64); +return x_10; +} +else +{ +lean_object* x_65; lean_object* x_66; +lean_free_object(x_10); +x_65 = lean_box(0); +x_66 = l_Lake_Package_test___lambda__1(x_12, x_20, x_3, x_65, x_4, x_14); +lean_dec(x_20); +return x_66; +} +} +} +} +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +lean_dec(x_22); +lean_dec(x_20); +lean_dec(x_16); +lean_free_object(x_10); +x_67 = lean_ctor_get(x_26, 0); +lean_inc(x_67); +lean_dec(x_26); +lean_ctor_set(x_12, 1, x_67); +x_68 = lean_alloc_closure((void*)(l_Lake_LeanExe_fetch), 7, 1); +lean_closure_set(x_68, 0, x_12); +lean_inc(x_4); +x_69 = l_Lake_Workspace_runFetchM___rarg(x_4, x_68, x_3, x_14); +if (lean_obj_tag(x_69) == 0) +{ +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_ctor_get(x_70, 0); +lean_inc(x_72); +lean_dec(x_70); +x_73 = lean_io_wait(x_72, x_71); +x_74 = lean_ctor_get(x_73, 0); +lean_inc(x_74); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; +x_75 = lean_ctor_get(x_73, 1); +lean_inc(x_75); +lean_dec(x_73); +x_76 = lean_ctor_get(x_74, 0); +lean_inc(x_76); +lean_dec(x_74); +x_77 = lean_ctor_get(x_76, 0); +lean_inc(x_77); +lean_dec(x_76); +x_78 = l_List_redLength___rarg(x_2); +x_79 = lean_mk_empty_array_with_capacity(x_78); +lean_dec(x_78); +x_80 = l_List_toArrayAux___rarg(x_2, x_79); +x_81 = l_Array_append___rarg(x_7, x_80); +lean_dec(x_80); +x_82 = l_Lake_env(x_77, x_81, x_4, x_75); +return x_82; +} +else +{ +uint8_t x_83; +lean_dec(x_74); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_83 = !lean_is_exclusive(x_73); +if (x_83 == 0) +{ +lean_object* x_84; lean_object* x_85; +x_84 = lean_ctor_get(x_73, 0); +lean_dec(x_84); +x_85 = l_Lake_exe___closed__4; +lean_ctor_set_tag(x_73, 1); +lean_ctor_set(x_73, 0, x_85); +return x_73; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_86 = lean_ctor_get(x_73, 1); +lean_inc(x_86); +lean_dec(x_73); +x_87 = l_Lake_exe___closed__4; +x_88 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_86); +return x_88; +} +} +} +else +{ +uint8_t x_89; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_89 = !lean_is_exclusive(x_69); +if (x_89 == 0) +{ +return x_69; +} +else +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_69, 0); +x_91 = lean_ctor_get(x_69, 1); +lean_inc(x_91); +lean_inc(x_90); +lean_dec(x_69); +x_92 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_92, 0, x_90); +lean_ctor_set(x_92, 1, x_91); +return x_92; +} +} +} +} +else +{ +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +lean_dec(x_22); +lean_dec(x_20); +lean_free_object(x_12); +lean_dec(x_16); +lean_dec(x_15); +lean_free_object(x_10); +lean_dec(x_3); +x_93 = lean_ctor_get(x_23, 0); +lean_inc(x_93); +lean_dec(x_23); +x_94 = lean_array_to_list(lean_box(0), x_7); +x_95 = l_List_appendTR___rarg(x_94, x_2); +x_96 = l_Lake_Script_run(x_95, x_93, x_4, x_14); +return x_96; +} +} +else +{ +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_97 = lean_ctor_get(x_10, 1); +x_98 = lean_ctor_get(x_12, 0); +x_99 = lean_ctor_get(x_12, 1); +lean_inc(x_99); +lean_inc(x_98); +lean_dec(x_12); +x_100 = lean_ctor_get(x_98, 2); +lean_inc(x_100); +x_101 = lean_ctor_get(x_100, 2); +lean_inc(x_101); +lean_dec(x_100); +x_102 = 0; +x_103 = l_Lean_Name_toString(x_101, x_102); +x_104 = lean_ctor_get(x_98, 13); +lean_inc(x_104); +lean_inc(x_99); +x_105 = l_String_toName(x_99); +x_106 = l_Lean_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_104, x_105); +lean_dec(x_104); +if (lean_obj_tag(x_106) == 0) +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_107 = lean_ctor_get(x_98, 9); +lean_inc(x_107); +x_108 = lean_ctor_get(x_107, 0); +lean_inc(x_108); +lean_dec(x_107); +x_109 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_108, x_105); +lean_dec(x_108); +if (lean_obj_tag(x_109) == 0) +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_98, 8); +lean_inc(x_110); +x_111 = lean_ctor_get(x_110, 0); +lean_inc(x_111); +lean_dec(x_110); +x_112 = l_Lean_RBNode_find___at_Lake_Package_findLeanLib_x3f___spec__1(x_111, x_105); +lean_dec(x_105); +lean_dec(x_111); +if (lean_obj_tag(x_112) == 0) +{ +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_dec(x_98); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_113 = l_Lake_Package_pack___closed__2; +x_114 = lean_string_append(x_113, x_103); +lean_dec(x_103); +x_115 = l_Lake_Package_test___closed__2; +x_116 = lean_string_append(x_114, x_115); +x_117 = lean_string_append(x_116, x_99); +lean_dec(x_99); +x_118 = l_Lake_Package_resolveDriver___closed__6; +x_119 = lean_string_append(x_117, x_118); +x_120 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_120); +return x_10; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; +lean_dec(x_99); +x_121 = lean_ctor_get(x_112, 0); +lean_inc(x_121); +if (lean_is_exclusive(x_112)) { + lean_ctor_release(x_112, 0); + x_122 = x_112; +} else { + lean_dec_ref(x_112); + x_122 = lean_box(0); +} +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_98); +lean_ctor_set(x_123, 1, x_121); +x_124 = l_Array_isEmpty___rarg(x_7); +lean_dec(x_7); +if (x_124 == 0) +{ +lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; +lean_dec(x_123); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_125 = l_Lake_Package_pack___closed__2; +x_126 = lean_string_append(x_125, x_103); +lean_dec(x_103); +x_127 = l_Lake_Package_test___closed__3; +x_128 = lean_string_append(x_126, x_127); +if (lean_is_scalar(x_122)) { + x_129 = lean_alloc_ctor(18, 1, 0); +} else { + x_129 = x_122; + lean_ctor_set_tag(x_129, 18); +} +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_129); +return x_10; +} +else +{ +uint8_t x_130; +x_130 = l_List_isEmpty___rarg(x_2); +lean_dec(x_2); +if (x_130 == 0) +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +lean_dec(x_123); +lean_dec(x_4); +lean_dec(x_3); +x_131 = l_Lake_Package_pack___closed__2; +x_132 = lean_string_append(x_131, x_103); +lean_dec(x_103); +x_133 = l_Lake_Package_test___closed__3; +x_134 = lean_string_append(x_132, x_133); +if (lean_is_scalar(x_122)) { + x_135 = lean_alloc_ctor(18, 1, 0); +} else { + x_135 = x_122; + lean_ctor_set_tag(x_135, 18); +} +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_135); +return x_10; +} +else +{ +lean_object* x_136; lean_object* x_137; +lean_dec(x_122); +lean_free_object(x_10); +x_136 = lean_box(0); +x_137 = l_Lake_Package_test___lambda__1(x_123, x_103, x_3, x_136, x_4, x_97); +lean_dec(x_103); +return x_137; +} +} +} +} +else +{ +lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +lean_dec(x_105); +lean_dec(x_103); +lean_dec(x_99); +lean_free_object(x_10); +x_138 = lean_ctor_get(x_109, 0); +lean_inc(x_138); +lean_dec(x_109); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_98); +lean_ctor_set(x_139, 1, x_138); +x_140 = lean_alloc_closure((void*)(l_Lake_LeanExe_fetch), 7, 1); +lean_closure_set(x_140, 0, x_139); +lean_inc(x_4); +x_141 = l_Lake_Workspace_runFetchM___rarg(x_4, x_140, x_3, x_97); +if (lean_obj_tag(x_141) == 0) +{ +lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; +x_142 = lean_ctor_get(x_141, 0); +lean_inc(x_142); +x_143 = lean_ctor_get(x_141, 1); +lean_inc(x_143); +lean_dec(x_141); +x_144 = lean_ctor_get(x_142, 0); +lean_inc(x_144); +lean_dec(x_142); +x_145 = lean_io_wait(x_144, x_143); +x_146 = lean_ctor_get(x_145, 0); +lean_inc(x_146); +if (lean_obj_tag(x_146) == 0) +{ +lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_147 = lean_ctor_get(x_145, 1); +lean_inc(x_147); +lean_dec(x_145); +x_148 = lean_ctor_get(x_146, 0); +lean_inc(x_148); +lean_dec(x_146); +x_149 = lean_ctor_get(x_148, 0); +lean_inc(x_149); +lean_dec(x_148); +x_150 = l_List_redLength___rarg(x_2); +x_151 = lean_mk_empty_array_with_capacity(x_150); +lean_dec(x_150); +x_152 = l_List_toArrayAux___rarg(x_2, x_151); +x_153 = l_Array_append___rarg(x_7, x_152); +lean_dec(x_152); +x_154 = l_Lake_env(x_149, x_153, x_4, x_147); +return x_154; +} +else +{ +lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +lean_dec(x_146); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_155 = lean_ctor_get(x_145, 1); +lean_inc(x_155); +if (lean_is_exclusive(x_145)) { + lean_ctor_release(x_145, 0); + lean_ctor_release(x_145, 1); + x_156 = x_145; +} else { + lean_dec_ref(x_145); + x_156 = lean_box(0); +} +x_157 = l_Lake_exe___closed__4; +if (lean_is_scalar(x_156)) { + x_158 = lean_alloc_ctor(1, 2, 0); +} else { + x_158 = x_156; + lean_ctor_set_tag(x_158, 1); +} +lean_ctor_set(x_158, 0, x_157); +lean_ctor_set(x_158, 1, x_155); +return x_158; +} +} +else +{ +lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_159 = lean_ctor_get(x_141, 0); +lean_inc(x_159); +x_160 = lean_ctor_get(x_141, 1); +lean_inc(x_160); +if (lean_is_exclusive(x_141)) { + lean_ctor_release(x_141, 0); + lean_ctor_release(x_141, 1); + x_161 = x_141; +} else { + lean_dec_ref(x_141); + x_161 = lean_box(0); +} +if (lean_is_scalar(x_161)) { + x_162 = lean_alloc_ctor(1, 2, 0); +} else { + x_162 = x_161; +} +lean_ctor_set(x_162, 0, x_159); +lean_ctor_set(x_162, 1, x_160); +return x_162; +} +} +} +else +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; +lean_dec(x_105); +lean_dec(x_103); +lean_dec(x_99); +lean_dec(x_98); +lean_free_object(x_10); +lean_dec(x_3); +x_163 = lean_ctor_get(x_106, 0); +lean_inc(x_163); +lean_dec(x_106); +x_164 = lean_array_to_list(lean_box(0), x_7); +x_165 = l_List_appendTR___rarg(x_164, x_2); +x_166 = l_Lake_Script_run(x_165, x_163, x_4, x_97); +return x_166; +} +} +} +else +{ +lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; +x_167 = lean_ctor_get(x_10, 0); +x_168 = lean_ctor_get(x_10, 1); +lean_inc(x_168); +lean_inc(x_167); +lean_dec(x_10); +x_169 = lean_ctor_get(x_167, 0); +lean_inc(x_169); +x_170 = lean_ctor_get(x_167, 1); +lean_inc(x_170); +if (lean_is_exclusive(x_167)) { + lean_ctor_release(x_167, 0); + lean_ctor_release(x_167, 1); + x_171 = x_167; +} else { + lean_dec_ref(x_167); + x_171 = lean_box(0); +} +x_172 = lean_ctor_get(x_169, 2); +lean_inc(x_172); +x_173 = lean_ctor_get(x_172, 2); +lean_inc(x_173); +lean_dec(x_172); +x_174 = 0; +x_175 = l_Lean_Name_toString(x_173, x_174); +x_176 = lean_ctor_get(x_169, 13); +lean_inc(x_176); +lean_inc(x_170); +x_177 = l_String_toName(x_170); +x_178 = l_Lean_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_176, x_177); +lean_dec(x_176); +if (lean_obj_tag(x_178) == 0) +{ +lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_179 = lean_ctor_get(x_169, 9); +lean_inc(x_179); +x_180 = lean_ctor_get(x_179, 0); +lean_inc(x_180); +lean_dec(x_179); +x_181 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_180, x_177); +lean_dec(x_180); +if (lean_obj_tag(x_181) == 0) +{ +lean_object* x_182; lean_object* x_183; lean_object* x_184; +x_182 = lean_ctor_get(x_169, 8); +lean_inc(x_182); +x_183 = lean_ctor_get(x_182, 0); +lean_inc(x_183); +lean_dec(x_182); +x_184 = l_Lean_RBNode_find___at_Lake_Package_findLeanLib_x3f___spec__1(x_183, x_177); +lean_dec(x_177); +lean_dec(x_183); +if (lean_obj_tag(x_184) == 0) +{ +lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; +lean_dec(x_171); +lean_dec(x_169); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_185 = l_Lake_Package_pack___closed__2; +x_186 = lean_string_append(x_185, x_175); +lean_dec(x_175); +x_187 = l_Lake_Package_test___closed__2; +x_188 = lean_string_append(x_186, x_187); +x_189 = lean_string_append(x_188, x_170); +lean_dec(x_170); +x_190 = l_Lake_Package_resolveDriver___closed__6; +x_191 = lean_string_append(x_189, x_190); +x_192 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_192, 0, x_191); +x_193 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_193, 0, x_192); +lean_ctor_set(x_193, 1, x_168); +return x_193; +} +else +{ +lean_object* x_194; lean_object* x_195; lean_object* x_196; uint8_t x_197; +lean_dec(x_170); +x_194 = lean_ctor_get(x_184, 0); +lean_inc(x_194); +if (lean_is_exclusive(x_184)) { + lean_ctor_release(x_184, 0); + x_195 = x_184; +} else { + lean_dec_ref(x_184); + x_195 = lean_box(0); +} +if (lean_is_scalar(x_171)) { + x_196 = lean_alloc_ctor(0, 2, 0); +} else { + x_196 = x_171; +} +lean_ctor_set(x_196, 0, x_169); +lean_ctor_set(x_196, 1, x_194); +x_197 = l_Array_isEmpty___rarg(x_7); +lean_dec(x_7); +if (x_197 == 0) +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; +lean_dec(x_196); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_198 = l_Lake_Package_pack___closed__2; +x_199 = lean_string_append(x_198, x_175); +lean_dec(x_175); +x_200 = l_Lake_Package_test___closed__3; +x_201 = lean_string_append(x_199, x_200); +if (lean_is_scalar(x_195)) { + x_202 = lean_alloc_ctor(18, 1, 0); +} else { + x_202 = x_195; + lean_ctor_set_tag(x_202, 18); +} +lean_ctor_set(x_202, 0, x_201); +x_203 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_203, 0, x_202); +lean_ctor_set(x_203, 1, x_168); +return x_203; +} +else +{ +uint8_t x_204; +x_204 = l_List_isEmpty___rarg(x_2); +lean_dec(x_2); +if (x_204 == 0) +{ +lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; +lean_dec(x_196); +lean_dec(x_4); +lean_dec(x_3); +x_205 = l_Lake_Package_pack___closed__2; +x_206 = lean_string_append(x_205, x_175); +lean_dec(x_175); +x_207 = l_Lake_Package_test___closed__3; +x_208 = lean_string_append(x_206, x_207); +if (lean_is_scalar(x_195)) { + x_209 = lean_alloc_ctor(18, 1, 0); +} else { + x_209 = x_195; + lean_ctor_set_tag(x_209, 18); +} +lean_ctor_set(x_209, 0, x_208); +x_210 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_210, 0, x_209); +lean_ctor_set(x_210, 1, x_168); +return x_210; +} +else +{ +lean_object* x_211; lean_object* x_212; +lean_dec(x_195); +x_211 = lean_box(0); +x_212 = l_Lake_Package_test___lambda__1(x_196, x_175, x_3, x_211, x_4, x_168); +lean_dec(x_175); +return x_212; +} +} +} +} +else +{ +lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; +lean_dec(x_177); +lean_dec(x_175); +lean_dec(x_170); +x_213 = lean_ctor_get(x_181, 0); +lean_inc(x_213); +lean_dec(x_181); +if (lean_is_scalar(x_171)) { + x_214 = lean_alloc_ctor(0, 2, 0); +} else { + x_214 = x_171; +} +lean_ctor_set(x_214, 0, x_169); +lean_ctor_set(x_214, 1, x_213); +x_215 = lean_alloc_closure((void*)(l_Lake_LeanExe_fetch), 7, 1); +lean_closure_set(x_215, 0, x_214); +lean_inc(x_4); +x_216 = l_Lake_Workspace_runFetchM___rarg(x_4, x_215, x_3, x_168); +if (lean_obj_tag(x_216) == 0) +{ +lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; +x_217 = lean_ctor_get(x_216, 0); +lean_inc(x_217); +x_218 = lean_ctor_get(x_216, 1); +lean_inc(x_218); +lean_dec(x_216); +x_219 = lean_ctor_get(x_217, 0); +lean_inc(x_219); +lean_dec(x_217); +x_220 = lean_io_wait(x_219, x_218); +x_221 = lean_ctor_get(x_220, 0); +lean_inc(x_221); +if (lean_obj_tag(x_221) == 0) +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; +x_222 = lean_ctor_get(x_220, 1); +lean_inc(x_222); +lean_dec(x_220); +x_223 = lean_ctor_get(x_221, 0); +lean_inc(x_223); +lean_dec(x_221); +x_224 = lean_ctor_get(x_223, 0); +lean_inc(x_224); +lean_dec(x_223); +x_225 = l_List_redLength___rarg(x_2); +x_226 = lean_mk_empty_array_with_capacity(x_225); +lean_dec(x_225); +x_227 = l_List_toArrayAux___rarg(x_2, x_226); +x_228 = l_Array_append___rarg(x_7, x_227); +lean_dec(x_227); +x_229 = l_Lake_env(x_224, x_228, x_4, x_222); +return x_229; +} +else +{ +lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; +lean_dec(x_221); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_230 = lean_ctor_get(x_220, 1); +lean_inc(x_230); +if (lean_is_exclusive(x_220)) { + lean_ctor_release(x_220, 0); + lean_ctor_release(x_220, 1); + x_231 = x_220; +} else { + lean_dec_ref(x_220); + x_231 = lean_box(0); +} +x_232 = l_Lake_exe___closed__4; +if (lean_is_scalar(x_231)) { + x_233 = lean_alloc_ctor(1, 2, 0); +} else { + x_233 = x_231; + lean_ctor_set_tag(x_233, 1); +} +lean_ctor_set(x_233, 0, x_232); +lean_ctor_set(x_233, 1, x_230); +return x_233; +} +} +else +{ +lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_234 = lean_ctor_get(x_216, 0); +lean_inc(x_234); +x_235 = lean_ctor_get(x_216, 1); +lean_inc(x_235); +if (lean_is_exclusive(x_216)) { + lean_ctor_release(x_216, 0); + lean_ctor_release(x_216, 1); + x_236 = x_216; +} else { + lean_dec_ref(x_216); + x_236 = lean_box(0); +} +if (lean_is_scalar(x_236)) { + x_237 = lean_alloc_ctor(1, 2, 0); +} else { + x_237 = x_236; +} +lean_ctor_set(x_237, 0, x_234); +lean_ctor_set(x_237, 1, x_235); +return x_237; +} +} +} +else +{ +lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; +lean_dec(x_177); +lean_dec(x_175); +lean_dec(x_171); +lean_dec(x_170); +lean_dec(x_169); +lean_dec(x_3); +x_238 = lean_ctor_get(x_178, 0); +lean_inc(x_238); +lean_dec(x_178); +x_239 = lean_array_to_list(lean_box(0), x_7); +x_240 = l_List_appendTR___rarg(x_239, x_2); +x_241 = l_Lake_Script_run(x_240, x_238, x_4, x_168); +return x_241; +} +} +} +else +{ +uint8_t x_242; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_242 = !lean_is_exclusive(x_10); +if (x_242 == 0) +{ +return x_10; +} +else +{ +lean_object* x_243; lean_object* x_244; lean_object* x_245; +x_243 = lean_ctor_get(x_10, 0); +x_244 = lean_ctor_get(x_10, 1); +lean_inc(x_244); +lean_inc(x_243); +lean_dec(x_10); +x_245 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_245, 0, x_243); +lean_ctor_set(x_245, 1, x_244); +return x_245; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_Package_test___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +lean_object* x_7; +x_7 = l_Lake_Package_test___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6); +lean_dec(x_4); +lean_dec(x_2); +return x_7; +} +} +static lean_object* _init_l_Lake_Package_lint___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("lint", 4); +return x_1; +} +} +static lean_object* _init_l_Lake_Package_lint___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(": invalid lint driver: unknown script or executable '", 53); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_Package_lint(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_6 = lean_ctor_get(x_1, 2); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 20); +lean_inc(x_7); +lean_dec(x_6); +x_8 = lean_ctor_get(x_1, 17); +lean_inc(x_8); +x_9 = l_Lake_Package_lint___closed__1; +x_10 = l_Lake_Package_resolveDriver(x_1, x_9, x_8, x_4, x_5); +lean_dec(x_8); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = lean_ctor_get(x_10, 0); +x_13 = !lean_is_exclusive(x_12); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_14 = lean_ctor_get(x_10, 1); +x_15 = lean_ctor_get(x_12, 0); +x_16 = lean_ctor_get(x_12, 1); +x_17 = lean_ctor_get(x_15, 13); +lean_inc(x_17); +lean_inc(x_16); +x_18 = l_String_toName(x_16); +x_19 = l_Lean_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_17, x_18); +lean_dec(x_17); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = lean_ctor_get(x_15, 9); +lean_inc(x_20); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +lean_dec(x_20); +x_22 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_21, x_18); +lean_dec(x_18); +lean_dec(x_21); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_free_object(x_12); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_23 = lean_ctor_get(x_15, 2); +lean_inc(x_23); +lean_dec(x_15); +x_24 = lean_ctor_get(x_23, 2); +lean_inc(x_24); +lean_dec(x_23); +x_25 = 0; +x_26 = l_Lean_Name_toString(x_24, x_25); +x_27 = l_Lake_Package_pack___closed__2; +x_28 = lean_string_append(x_27, x_26); +lean_dec(x_26); +x_29 = l_Lake_Package_lint___closed__2; +x_30 = lean_string_append(x_28, x_29); +x_31 = lean_string_append(x_30, x_16); +lean_dec(x_16); +x_32 = l_Lake_Package_resolveDriver___closed__6; +x_33 = lean_string_append(x_31, x_32); +x_34 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_34); +return x_10; +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_dec(x_16); +lean_free_object(x_10); +x_35 = lean_ctor_get(x_22, 0); +lean_inc(x_35); +lean_dec(x_22); +lean_ctor_set(x_12, 1, x_35); +x_36 = lean_alloc_closure((void*)(l_Lake_LeanExe_fetch), 7, 1); +lean_closure_set(x_36, 0, x_12); +lean_inc(x_4); +x_37 = l_Lake_Workspace_runFetchM___rarg(x_4, x_36, x_3, x_14); +if (lean_obj_tag(x_37) == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_38 = lean_ctor_get(x_37, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_37, 1); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_ctor_get(x_38, 0); +lean_inc(x_40); +lean_dec(x_38); +x_41 = lean_io_wait(x_40, x_39); +x_42 = lean_ctor_get(x_41, 0); +lean_inc(x_42); +if (lean_obj_tag(x_42) == 0) +{ +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_43 = lean_ctor_get(x_41, 1); +lean_inc(x_43); +lean_dec(x_41); +x_44 = lean_ctor_get(x_42, 0); +lean_inc(x_44); +lean_dec(x_42); +x_45 = lean_ctor_get(x_44, 0); +lean_inc(x_45); +lean_dec(x_44); +x_46 = l_List_redLength___rarg(x_2); +x_47 = lean_mk_empty_array_with_capacity(x_46); +lean_dec(x_46); +x_48 = l_List_toArrayAux___rarg(x_2, x_47); +x_49 = l_Array_append___rarg(x_7, x_48); +lean_dec(x_48); +x_50 = l_Lake_env(x_45, x_49, x_4, x_43); +return x_50; +} +else +{ +uint8_t x_51; +lean_dec(x_42); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_51 = !lean_is_exclusive(x_41); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; +x_52 = lean_ctor_get(x_41, 0); +lean_dec(x_52); +x_53 = l_Lake_exe___closed__4; +lean_ctor_set_tag(x_41, 1); +lean_ctor_set(x_41, 0, x_53); +return x_41; +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_41, 1); +lean_inc(x_54); +lean_dec(x_41); +x_55 = l_Lake_exe___closed__4; +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_54); +return x_56; +} +} +} +else +{ +uint8_t x_57; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_57 = !lean_is_exclusive(x_37); +if (x_57 == 0) +{ +return x_37; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_37, 0); +x_59 = lean_ctor_get(x_37, 1); +lean_inc(x_59); +lean_inc(x_58); +lean_dec(x_37); +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set(x_60, 1, x_59); +return x_60; +} +} +} +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +lean_dec(x_18); +lean_free_object(x_12); +lean_dec(x_16); +lean_dec(x_15); +lean_free_object(x_10); +lean_dec(x_3); +x_61 = lean_ctor_get(x_19, 0); +lean_inc(x_61); +lean_dec(x_19); +x_62 = lean_array_data(x_7); +x_63 = l_List_appendTR___rarg(x_62, x_2); +x_64 = l_Lake_Script_run(x_63, x_61, x_4, x_14); +return x_64; +} +} +else +{ +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_65 = lean_ctor_get(x_10, 1); +x_66 = lean_ctor_get(x_12, 0); +x_67 = lean_ctor_get(x_12, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_12); +x_68 = lean_ctor_get(x_66, 13); +lean_inc(x_68); +lean_inc(x_67); +x_69 = l_String_toName(x_67); +x_70 = l_Lean_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_68, x_69); +lean_dec(x_68); +if (lean_obj_tag(x_70) == 0) +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_71 = lean_ctor_get(x_66, 9); +lean_inc(x_71); +x_72 = lean_ctor_get(x_71, 0); +lean_inc(x_72); +lean_dec(x_71); +x_73 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_72, x_69); +lean_dec(x_69); +lean_dec(x_72); +if (lean_obj_tag(x_73) == 0) +{ +lean_object* x_74; lean_object* x_75; uint8_t x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_74 = lean_ctor_get(x_66, 2); +lean_inc(x_74); +lean_dec(x_66); +x_75 = lean_ctor_get(x_74, 2); +lean_inc(x_75); +lean_dec(x_74); +x_76 = 0; +x_77 = l_Lean_Name_toString(x_75, x_76); +x_78 = l_Lake_Package_pack___closed__2; +x_79 = lean_string_append(x_78, x_77); +lean_dec(x_77); +x_80 = l_Lake_Package_lint___closed__2; +x_81 = lean_string_append(x_79, x_80); +x_82 = lean_string_append(x_81, x_67); +lean_dec(x_67); +x_83 = l_Lake_Package_resolveDriver___closed__6; +x_84 = lean_string_append(x_82, x_83); +x_85 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set_tag(x_10, 1); +lean_ctor_set(x_10, 0, x_85); +return x_10; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +lean_dec(x_67); +lean_free_object(x_10); +x_86 = lean_ctor_get(x_73, 0); +lean_inc(x_86); +lean_dec(x_73); +x_87 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_87, 0, x_66); +lean_ctor_set(x_87, 1, x_86); +x_88 = lean_alloc_closure((void*)(l_Lake_LeanExe_fetch), 7, 1); +lean_closure_set(x_88, 0, x_87); +lean_inc(x_4); +x_89 = l_Lake_Workspace_runFetchM___rarg(x_4, x_88, x_3, x_65); +if (lean_obj_tag(x_89) == 0) +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_90 = lean_ctor_get(x_89, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_89, 1); +lean_inc(x_91); +lean_dec(x_89); +x_92 = lean_ctor_get(x_90, 0); +lean_inc(x_92); +lean_dec(x_90); +x_93 = lean_io_wait(x_92, x_91); +x_94 = lean_ctor_get(x_93, 0); +lean_inc(x_94); +if (lean_obj_tag(x_94) == 0) +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; +x_95 = lean_ctor_get(x_93, 1); +lean_inc(x_95); +lean_dec(x_93); +x_96 = lean_ctor_get(x_94, 0); +lean_inc(x_96); +lean_dec(x_94); +x_97 = lean_ctor_get(x_96, 0); +lean_inc(x_97); +lean_dec(x_96); +x_98 = l_List_redLength___rarg(x_2); +x_99 = lean_mk_empty_array_with_capacity(x_98); +lean_dec(x_98); +x_100 = l_List_toArrayAux___rarg(x_2, x_99); +x_101 = l_Array_append___rarg(x_7, x_100); +lean_dec(x_100); +x_102 = l_Lake_env(x_97, x_101, x_4, x_95); +return x_102; +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; +lean_dec(x_94); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_103 = lean_ctor_get(x_93, 1); +lean_inc(x_103); +if (lean_is_exclusive(x_93)) { + lean_ctor_release(x_93, 0); + lean_ctor_release(x_93, 1); + x_104 = x_93; +} else { + lean_dec_ref(x_93); + x_104 = lean_box(0); +} +x_105 = l_Lake_exe___closed__4; +if (lean_is_scalar(x_104)) { + x_106 = lean_alloc_ctor(1, 2, 0); +} else { + x_106 = x_104; + lean_ctor_set_tag(x_106, 1); +} +lean_ctor_set(x_106, 0, x_105); +lean_ctor_set(x_106, 1, x_103); +return x_106; +} +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_107 = lean_ctor_get(x_89, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_89, 1); +lean_inc(x_108); +if (lean_is_exclusive(x_89)) { + lean_ctor_release(x_89, 0); + lean_ctor_release(x_89, 1); + x_109 = x_89; +} else { + lean_dec_ref(x_89); + x_109 = lean_box(0); +} +if (lean_is_scalar(x_109)) { + x_110 = lean_alloc_ctor(1, 2, 0); +} else { + x_110 = x_109; +} +lean_ctor_set(x_110, 0, x_107); +lean_ctor_set(x_110, 1, x_108); +return x_110; +} +} +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; +lean_dec(x_69); +lean_dec(x_67); +lean_dec(x_66); +lean_free_object(x_10); +lean_dec(x_3); +x_111 = lean_ctor_get(x_70, 0); +lean_inc(x_111); +lean_dec(x_70); +x_112 = lean_array_data(x_7); +x_113 = l_List_appendTR___rarg(x_112, x_2); +x_114 = l_Lake_Script_run(x_113, x_111, x_4, x_65); +return x_114; +} +} +} +else +{ +lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; +x_115 = lean_ctor_get(x_10, 0); +x_116 = lean_ctor_get(x_10, 1); +lean_inc(x_116); +lean_inc(x_115); +lean_dec(x_10); +x_117 = lean_ctor_get(x_115, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_115, 1); +lean_inc(x_118); +if (lean_is_exclusive(x_115)) { + lean_ctor_release(x_115, 0); + lean_ctor_release(x_115, 1); + x_119 = x_115; +} else { + lean_dec_ref(x_115); + x_119 = lean_box(0); +} +x_120 = lean_ctor_get(x_117, 13); +lean_inc(x_120); +lean_inc(x_118); +x_121 = l_String_toName(x_118); +x_122 = l_Lean_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_120, x_121); +lean_dec(x_120); +if (lean_obj_tag(x_122) == 0) +{ +lean_object* x_123; lean_object* x_124; lean_object* x_125; +x_123 = lean_ctor_get(x_117, 9); +lean_inc(x_123); +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +lean_dec(x_123); +x_125 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_124, x_121); +lean_dec(x_121); +lean_dec(x_124); +if (lean_obj_tag(x_125) == 0) +{ +lean_object* x_126; lean_object* x_127; uint8_t x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; +lean_dec(x_119); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_126 = lean_ctor_get(x_117, 2); +lean_inc(x_126); +lean_dec(x_117); +x_127 = lean_ctor_get(x_126, 2); +lean_inc(x_127); +lean_dec(x_126); +x_128 = 0; +x_129 = l_Lean_Name_toString(x_127, x_128); +x_130 = l_Lake_Package_pack___closed__2; +x_131 = lean_string_append(x_130, x_129); +lean_dec(x_129); +x_132 = l_Lake_Package_lint___closed__2; +x_133 = lean_string_append(x_131, x_132); +x_134 = lean_string_append(x_133, x_118); +lean_dec(x_118); +x_135 = l_Lake_Package_resolveDriver___closed__6; +x_136 = lean_string_append(x_134, x_135); +x_137 = lean_alloc_ctor(18, 1, 0); +lean_ctor_set(x_137, 0, x_136); +x_138 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_138, 0, x_137); +lean_ctor_set(x_138, 1, x_116); +return x_138; +} +else +{ +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; +lean_dec(x_118); +x_139 = lean_ctor_get(x_125, 0); +lean_inc(x_139); +lean_dec(x_125); +if (lean_is_scalar(x_119)) { + x_140 = lean_alloc_ctor(0, 2, 0); +} else { + x_140 = x_119; +} +lean_ctor_set(x_140, 0, x_117); +lean_ctor_set(x_140, 1, x_139); +x_141 = lean_alloc_closure((void*)(l_Lake_LeanExe_fetch), 7, 1); +lean_closure_set(x_141, 0, x_140); +lean_inc(x_4); +x_142 = l_Lake_Workspace_runFetchM___rarg(x_4, x_141, x_3, x_116); +if (lean_obj_tag(x_142) == 0) +{ +lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; +x_143 = lean_ctor_get(x_142, 0); +lean_inc(x_143); +x_144 = lean_ctor_get(x_142, 1); +lean_inc(x_144); +lean_dec(x_142); +x_145 = lean_ctor_get(x_143, 0); +lean_inc(x_145); +lean_dec(x_143); +x_146 = lean_io_wait(x_145, x_144); +x_147 = lean_ctor_get(x_146, 0); +lean_inc(x_147); +if (lean_obj_tag(x_147) == 0) +{ +lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; +x_148 = lean_ctor_get(x_146, 1); +lean_inc(x_148); +lean_dec(x_146); +x_149 = lean_ctor_get(x_147, 0); +lean_inc(x_149); +lean_dec(x_147); +x_150 = lean_ctor_get(x_149, 0); +lean_inc(x_150); +lean_dec(x_149); +x_151 = l_List_redLength___rarg(x_2); +x_152 = lean_mk_empty_array_with_capacity(x_151); +lean_dec(x_151); +x_153 = l_List_toArrayAux___rarg(x_2, x_152); +x_154 = l_Array_append___rarg(x_7, x_153); +lean_dec(x_153); +x_155 = l_Lake_env(x_150, x_154, x_4, x_148); +return x_155; +} +else +{ +lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; +lean_dec(x_147); +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_156 = lean_ctor_get(x_146, 1); +lean_inc(x_156); +if (lean_is_exclusive(x_146)) { + lean_ctor_release(x_146, 0); + lean_ctor_release(x_146, 1); + x_157 = x_146; +} else { + lean_dec_ref(x_146); + x_157 = lean_box(0); +} +x_158 = l_Lake_exe___closed__4; +if (lean_is_scalar(x_157)) { + x_159 = lean_alloc_ctor(1, 2, 0); +} else { + x_159 = x_157; + lean_ctor_set_tag(x_159, 1); +} +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_156); +return x_159; +} +} +else +{ +lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_2); +x_160 = lean_ctor_get(x_142, 0); +lean_inc(x_160); +x_161 = lean_ctor_get(x_142, 1); +lean_inc(x_161); +if (lean_is_exclusive(x_142)) { + lean_ctor_release(x_142, 0); + lean_ctor_release(x_142, 1); + x_162 = x_142; +} else { + lean_dec_ref(x_142); + x_162 = lean_box(0); +} +if (lean_is_scalar(x_162)) { + x_163 = lean_alloc_ctor(1, 2, 0); +} else { + x_163 = x_162; +} +lean_ctor_set(x_163, 0, x_160); +lean_ctor_set(x_163, 1, x_161); +return x_163; +} +} +} +else +{ +lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; +lean_dec(x_121); +lean_dec(x_119); +lean_dec(x_118); +lean_dec(x_117); +lean_dec(x_3); +x_164 = lean_ctor_get(x_122, 0); +lean_inc(x_164); +lean_dec(x_122); +x_165 = lean_array_data(x_7); +x_166 = l_List_appendTR___rarg(x_165, x_2); +x_167 = l_Lake_Script_run(x_166, x_164, x_4, x_116); +return x_167; +} +} +} +else +{ +uint8_t x_168; +lean_dec(x_7); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_168 = !lean_is_exclusive(x_10); +if (x_168 == 0) +{ +return x_10; +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; +x_169 = lean_ctor_get(x_10, 0); +x_170 = lean_ctor_get(x_10, 1); +lean_inc(x_170); +lean_inc(x_169); +lean_dec(x_10); +x_171 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_171, 0, x_169); +lean_ctor_set(x_171, 1, x_170); +return x_171; +} +} +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Run(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Targets(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_CLI_Build(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_CLI_Actions(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Run(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Targets(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_CLI_Build(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_env___closed__1 = _init_l_Lake_env___closed__1(); +lean_mark_persistent(l_Lake_env___closed__1); +l_Lake_exe___closed__1 = _init_l_Lake_exe___closed__1(); +lean_mark_persistent(l_Lake_exe___closed__1); +l_Lake_exe___closed__2 = _init_l_Lake_exe___closed__2(); +lean_mark_persistent(l_Lake_exe___closed__2); +l_Lake_exe___closed__3 = _init_l_Lake_exe___closed__3(); +lean_mark_persistent(l_Lake_exe___closed__3); +l_Lake_exe___closed__4 = _init_l_Lake_exe___closed__4(); +lean_mark_persistent(l_Lake_exe___closed__4); +l_Lake_Package_pack___closed__1 = _init_l_Lake_Package_pack___closed__1(); +lean_mark_persistent(l_Lake_Package_pack___closed__1); +l_Lake_Package_pack___closed__2 = _init_l_Lake_Package_pack___closed__2(); +lean_mark_persistent(l_Lake_Package_pack___closed__2); +l_Lake_Package_pack___closed__3 = _init_l_Lake_Package_pack___closed__3(); +lean_mark_persistent(l_Lake_Package_pack___closed__3); +l_Lake_Package_unpack___closed__1 = _init_l_Lake_Package_unpack___closed__1(); +lean_mark_persistent(l_Lake_Package_unpack___closed__1); +l_Lake_Package_uploadRelease___lambda__1___closed__1 = _init_l_Lake_Package_uploadRelease___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_Package_uploadRelease___lambda__1___closed__1); +l_Lake_Package_uploadRelease___closed__1 = _init_l_Lake_Package_uploadRelease___closed__1(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__1); +l_Lake_Package_uploadRelease___closed__2 = _init_l_Lake_Package_uploadRelease___closed__2(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__2); +l_Lake_Package_uploadRelease___closed__3 = _init_l_Lake_Package_uploadRelease___closed__3(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__3); +l_Lake_Package_uploadRelease___closed__4 = _init_l_Lake_Package_uploadRelease___closed__4(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__4); +l_Lake_Package_uploadRelease___closed__5 = _init_l_Lake_Package_uploadRelease___closed__5(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__5); +l_Lake_Package_uploadRelease___closed__6 = _init_l_Lake_Package_uploadRelease___closed__6(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__6); +l_Lake_Package_uploadRelease___closed__7 = _init_l_Lake_Package_uploadRelease___closed__7(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__7); +l_Lake_Package_uploadRelease___closed__8 = _init_l_Lake_Package_uploadRelease___closed__8(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__8); +l_Lake_Package_uploadRelease___closed__9 = _init_l_Lake_Package_uploadRelease___closed__9(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__9); +l_Lake_Package_uploadRelease___closed__10 = _init_l_Lake_Package_uploadRelease___closed__10(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__10); +l_Lake_Package_uploadRelease___closed__11 = _init_l_Lake_Package_uploadRelease___closed__11(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__11); +l_Lake_Package_uploadRelease___closed__12 = _init_l_Lake_Package_uploadRelease___closed__12(); +lean_mark_persistent(l_Lake_Package_uploadRelease___closed__12); +l_Lake_Package_resolveDriver___closed__1 = _init_l_Lake_Package_resolveDriver___closed__1(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__1); +l_Lake_Package_resolveDriver___closed__2 = _init_l_Lake_Package_resolveDriver___closed__2(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__2); +l_Lake_Package_resolveDriver___closed__3 = _init_l_Lake_Package_resolveDriver___closed__3(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__3); +l_Lake_Package_resolveDriver___closed__4 = _init_l_Lake_Package_resolveDriver___closed__4(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__4); +l_Lake_Package_resolveDriver___closed__5 = _init_l_Lake_Package_resolveDriver___closed__5(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__5); +l_Lake_Package_resolveDriver___closed__6 = _init_l_Lake_Package_resolveDriver___closed__6(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__6); +l_Lake_Package_resolveDriver___closed__7 = _init_l_Lake_Package_resolveDriver___closed__7(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__7); +l_Lake_Package_resolveDriver___closed__8 = _init_l_Lake_Package_resolveDriver___closed__8(); +lean_mark_persistent(l_Lake_Package_resolveDriver___closed__8); +l_Lake_Package_test___lambda__1___closed__1 = _init_l_Lake_Package_test___lambda__1___closed__1(); +lean_mark_persistent(l_Lake_Package_test___lambda__1___closed__1); +l_Lake_Package_test___lambda__1___boxed__const__1 = _init_l_Lake_Package_test___lambda__1___boxed__const__1(); +lean_mark_persistent(l_Lake_Package_test___lambda__1___boxed__const__1); +l_Lake_Package_test___closed__1 = _init_l_Lake_Package_test___closed__1(); +lean_mark_persistent(l_Lake_Package_test___closed__1); +l_Lake_Package_test___closed__2 = _init_l_Lake_Package_test___closed__2(); +lean_mark_persistent(l_Lake_Package_test___closed__2); +l_Lake_Package_test___closed__3 = _init_l_Lake_Package_test___closed__3(); +lean_mark_persistent(l_Lake_Package_test___closed__3); +l_Lake_Package_lint___closed__1 = _init_l_Lake_Package_lint___closed__1(); +lean_mark_persistent(l_Lake_Package_lint___closed__1); +l_Lake_Package_lint___closed__2 = _init_l_Lake_Package_lint___closed__2(); +lean_mark_persistent(l_Lake_Package_lint___closed__2); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/CLI/Build.c b/stage0/stdlib/Lake/CLI/Build.c new file mode 100644 index 0000000000..49ead808d6 --- /dev/null +++ b/stage0/stdlib/Lake/CLI/Build.c @@ -0,0 +1,4734 @@ +// Lean compiler output +// Module: Lake.CLI.Build +// Imports: Init Lake.Build.Index Lake.CLI.Error +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +LEAN_EXPORT lean_object* l_Lake_resolveDefaultPackageTarget(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveTargetBaseSpec(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob___rarg(lean_object*); +lean_object* l_Lake_Workspace_findModuleFacetConfig_x3f(lean_object*, lean_object*); +lean_object* l_Lake_registerJob___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_parseTargetSpec(lean_object*, lean_object*); +lean_object* lean_mk_empty_array_with_capacity(lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +lean_object* l_Lake_BuildInfo_key(lean_object*); +static lean_object* l_Lake_resolveExternLibTarget___closed__3; +LEAN_EXPORT lean_object* l_Lake_parseTargetSpecs(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lake_parseTargetSpecs___spec__1(lean_object*, lean_object*, lean_object*); +lean_object* lean_mk_array(lean_object*, lean_object*); +uint8_t lean_usize_dec_eq(size_t, size_t); +uint8_t l_Lean_Name_isAnonymous(lean_object*); +static lean_object* l_Lake_resolveExeTarget___closed__2; +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_resolveLibTarget___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_parseExeTargetSpec___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveExeTarget(lean_object*, lean_object*); +lean_object* l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(lean_object*, lean_object*); +lean_object* l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(lean_object*, lean_object*); +lean_object* l_Lake_Workspace_findTargetModule_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveDefaultPackageTarget___boxed(lean_object*, lean_object*); +static lean_object* l_Lake_resolveLibTarget_resolveFacet___closed__1; +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_resolveTargetInPackage___spec__1(lean_object*, lean_object*, lean_object*); +size_t lean_usize_of_nat(lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveModuleTarget(lean_object*, lean_object*, lean_object*); +uint8_t l_String_isEmpty(lean_object*); +lean_object* l_Lake_Package_findTargetModule_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveExternLibTarget(lean_object*, lean_object*); +static lean_object* l_Lake_resolveExternLibTarget___closed__4; +LEAN_EXPORT lean_object* l_Lake_mkConfigBuildSpec___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_parsePackageSpec___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildSpecs___spec__1(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_resolveExternLibTarget___closed__2; +LEAN_EXPORT lean_object* l_Lake_parseTargetSpec___boxed__const__1; +lean_object* l_Lake_Workspace_findExternLib_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkBuildSpec(lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkBuildSpec___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_resolveLibTarget___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*); +lean_object* l_Lake_stringToLegalOrSimpleName(lean_object*); +lean_object* l_Lake_Workspace_findLibraryFacetConfig_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolvePackageTarget___boxed(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_resolvePackageTarget___closed__1; +uint8_t l_String_startsWith(lean_object*, lean_object*); +lean_object* l_Lake_BuildKey_toSimpleString(lean_object*); +LEAN_EXPORT lean_object* l_Lake_parseExeTargetSpec___boxed__const__1; +static lean_object* l_Lake_mkBuildSpec___rarg___closed__1; +lean_object* l_Lake_Package_findTargetConfig_x3f(lean_object*, lean_object*); +lean_object* l_Lake_Workspace_findPackageFacetConfig_x3f(lean_object*, lean_object*); +extern lean_object* l_Task_Priority_default; +static lean_object* l_Lake_parseTargetSpecs___closed__1; +uint8_t lean_name_eq(lean_object*, lean_object*); +lean_object* l_Lean_Name_str___override(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolvePackageTarget(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_resolveExternLibTarget___closed__5; +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_resolveExternLibTarget___closed__1; +static lean_object* l_Lake_resolveExeTarget___closed__3; +LEAN_EXPORT lean_object* l_Lake_resolveCustomTarget(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_EResult_map___rarg(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveModuleTarget___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_mkConfigBuildSpec(lean_object*, lean_object*); +static lean_object* l_Lake_resolveModuleTarget___closed__1; +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveTargetBaseSpec___boxed__const__1; +lean_object* l_Array_append___rarg(lean_object*, lean_object*); +static lean_object* l_Lake_parseTargetSpec___closed__1; +lean_object* l_Lake_Workspace_findLeanExe_x3f(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_parseExeTargetSpec(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_Workspace_findLeanLib_x3f(lean_object*, lean_object*); +lean_object* l_Lake_Workspace_findTargetConfig_x3f(lean_object*, lean_object*); +static lean_object* l_Lake_resolveTargetBaseSpec___closed__3; +static lean_object* l_Lake_resolveModuleTarget___closed__3; +static lean_object* l_Lake_resolveModuleTarget___closed__2; +uint8_t lean_nat_dec_lt(lean_object*, lean_object*); +static lean_object* l_Lake_resolveDefaultPackageTarget___closed__1; +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_resolveDefaultPackageTarget___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lake_BuildJob_mixArray___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob___rarg___lambda__1(lean_object*); +static lean_object* l_Lake_resolveTargetBaseSpec___closed__2; +lean_object* l_String_toName(lean_object*); +static lean_object* l_Lake_resolveTargetBaseSpec___closed__1; +lean_object* lean_task_map(lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* l_Lake_parsePackageSpec(lean_object*, lean_object*); +static lean_object* l_Lake_BuildData_toBuildJob___rarg___closed__1; +LEAN_EXPORT lean_object* l_Lake_parseTargetSpecs___lambda__1___boxed(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildSpec_fetch(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +uint8_t l_Lean_Name_quickCmp(lean_object*, lean_object*); +static lean_object* l_Lake_resolveExeTarget___closed__1; +size_t lean_usize_add(size_t, size_t); +LEAN_EXPORT lean_object* l_Lake_resolveTargetInWorkspace___boxed(lean_object*, lean_object*, lean_object*); +lean_object* lean_array_uget(lean_object*, size_t); +lean_object* l_Lean_RBNode_find___at_Lake_Package_findLeanLib_x3f___spec__1(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveTargetInPackage___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_buildSpecs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_get_size(lean_object*); +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildSpecs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_parseTargetSpecs___lambda__1(lean_object*, lean_object*); +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +uint8_t lean_usize_dec_lt(size_t, size_t); +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_resolveDefaultPackageTarget___spec__1(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*); +static lean_object* l_Lake_resolveDefaultPackageTarget___closed__2; +LEAN_EXPORT lean_object* l_Lake_resolveTargetInWorkspace(lean_object*, lean_object*, lean_object*); +static lean_object* l_Lake_BuildData_toBuildJob___rarg___closed__2; +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget_resolveFacet(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveTargetInPackage(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* lean_array_uset(lean_object*, size_t, lean_object*); +lean_object* l_String_drop(lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget_resolveFacet___boxed(lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_resolveTargetInPackage___spec__1___boxed(lean_object*, lean_object*, lean_object*); +lean_object* l_String_splitOn(lean_object*, lean_object*); +uint8_t l_Array_isEmpty___rarg(lean_object*); +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob___rarg___lambda__1(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; +x_3 = lean_ctor_get(x_1, 0); +lean_dec(x_3); +x_4 = lean_box(0); +lean_ctor_set(x_1, 0, x_4); +return x_1; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_1, 1); +lean_inc(x_5); +lean_dec(x_1); +x_6 = lean_box(0); +x_7 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_5); +return x_7; +} +} +} +static lean_object* _init_l_Lake_BuildData_toBuildJob___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildData_toBuildJob___rarg___lambda__1), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_BuildData_toBuildJob___rarg___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_BuildData_toBuildJob___rarg___closed__1; +x_2 = lean_alloc_closure((void*)(l_Lake_EResult_map___rarg), 2, 1); +lean_closure_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob___rarg(lean_object* x_1) { +_start: +{ +uint8_t x_2; +x_2 = !lean_is_exclusive(x_1); +if (x_2 == 0) +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +x_4 = l_Lake_BuildData_toBuildJob___rarg___closed__2; +x_5 = l_Task_Priority_default; +x_6 = 0; +x_7 = lean_task_map(x_4, x_3, x_5, x_6); +lean_ctor_set(x_1, 0, x_7); +return x_1; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; +x_8 = lean_ctor_get(x_1, 0); +x_9 = lean_ctor_get(x_1, 1); +lean_inc(x_9); +lean_inc(x_8); +lean_dec(x_1); +x_10 = l_Lake_BuildData_toBuildJob___rarg___closed__2; +x_11 = l_Task_Priority_default; +x_12 = 0; +x_13 = lean_task_map(x_10, x_8, x_11, x_12); +x_14 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_14, 0, x_13); +lean_ctor_set(x_14, 1, x_9); +return x_14; +} +} +} +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = lean_alloc_closure((void*)(l_Lake_BuildData_toBuildJob___rarg), 1, 0); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildData_toBuildJob___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_BuildData_toBuildJob(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +static lean_object* _init_l_Lake_mkBuildSpec___rarg___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_BuildData_toBuildJob___rarg), 1, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_mkBuildSpec___rarg(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = l_Lake_mkBuildSpec___rarg___closed__1; +x_4 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_4, 0, x_1); +lean_ctor_set(x_4, 1, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_mkBuildSpec(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lake_mkBuildSpec___rarg), 2, 0); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_mkConfigBuildSpec___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +lean_object* x_6; +x_6 = lean_ctor_get(x_4, 1); +lean_inc(x_6); +lean_dec(x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; lean_object* x_8; +lean_dec(x_3); +x_7 = lean_alloc_ctor(16, 2, 0); +lean_ctor_set(x_7, 0, x_2); +lean_ctor_set(x_7, 1, x_1); +x_8 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; +} +else +{ +uint8_t x_9; +lean_dec(x_2); +lean_dec(x_1); +x_9 = !lean_is_exclusive(x_6); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_6, 0); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_3); +lean_ctor_set(x_11, 1, x_10); +lean_ctor_set(x_6, 0, x_11); +return x_6; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_6, 0); +lean_inc(x_12); +lean_dec(x_6); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_3); +lean_ctor_set(x_13, 1, x_12); +x_14 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_14, 0, x_13); +return x_14; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_mkConfigBuildSpec(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_closure((void*)(l_Lake_mkConfigBuildSpec___rarg), 5, 0); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_BuildSpec_fetch(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_62; +x_8 = lean_ctor_get(x_1, 1); +lean_inc(x_8); +x_9 = lean_ctor_get(x_1, 0); +lean_inc(x_9); +lean_dec(x_1); +lean_inc(x_2); +lean_inc(x_4); +lean_inc(x_3); +lean_inc(x_9); +x_62 = lean_apply_6(x_2, x_9, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_62) == 0) +{ +lean_object* x_63; lean_object* x_64; +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +x_64 = lean_ctor_get(x_63, 0); +lean_inc(x_64); +if (lean_obj_tag(x_64) == 0) +{ +lean_object* x_65; uint8_t x_66; +x_65 = lean_ctor_get(x_62, 1); +lean_inc(x_65); +lean_dec(x_62); +x_66 = !lean_is_exclusive(x_63); +if (x_66 == 0) +{ +lean_object* x_67; uint8_t x_68; +x_67 = lean_ctor_get(x_63, 0); +lean_dec(x_67); +x_68 = !lean_is_exclusive(x_64); +if (x_68 == 0) +{ +lean_object* x_69; lean_object* x_70; +x_69 = lean_ctor_get(x_64, 0); +x_70 = lean_apply_1(x_8, x_69); +lean_ctor_set(x_64, 0, x_70); +x_10 = x_63; +x_11 = x_65; +goto block_61; +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_71 = lean_ctor_get(x_64, 0); +x_72 = lean_ctor_get(x_64, 1); +lean_inc(x_72); +lean_inc(x_71); +lean_dec(x_64); +x_73 = lean_apply_1(x_8, x_71); +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_73); +lean_ctor_set(x_74, 1, x_72); +lean_ctor_set(x_63, 0, x_74); +x_10 = x_63; +x_11 = x_65; +goto block_61; +} +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_75 = lean_ctor_get(x_63, 1); +lean_inc(x_75); +lean_dec(x_63); +x_76 = lean_ctor_get(x_64, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_64, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_78 = x_64; +} else { + lean_dec_ref(x_64); + x_78 = lean_box(0); +} +x_79 = lean_apply_1(x_8, x_76); +if (lean_is_scalar(x_78)) { + x_80 = lean_alloc_ctor(0, 2, 0); +} else { + x_80 = x_78; +} +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_77); +x_81 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_81, 0, x_80); +lean_ctor_set(x_81, 1, x_75); +x_10 = x_81; +x_11 = x_65; +goto block_61; +} +} +else +{ +lean_object* x_82; uint8_t x_83; +lean_dec(x_8); +x_82 = lean_ctor_get(x_62, 1); +lean_inc(x_82); +lean_dec(x_62); +x_83 = !lean_is_exclusive(x_63); +if (x_83 == 0) +{ +lean_object* x_84; uint8_t x_85; +x_84 = lean_ctor_get(x_63, 0); +lean_dec(x_84); +x_85 = !lean_is_exclusive(x_64); +if (x_85 == 0) +{ +x_10 = x_63; +x_11 = x_82; +goto block_61; +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_86 = lean_ctor_get(x_64, 0); +x_87 = lean_ctor_get(x_64, 1); +lean_inc(x_87); +lean_inc(x_86); +lean_dec(x_64); +x_88 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_88, 0, x_86); +lean_ctor_set(x_88, 1, x_87); +lean_ctor_set(x_63, 0, x_88); +x_10 = x_63; +x_11 = x_82; +goto block_61; +} +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_89 = lean_ctor_get(x_63, 1); +lean_inc(x_89); +lean_dec(x_63); +x_90 = lean_ctor_get(x_64, 0); +lean_inc(x_90); +x_91 = lean_ctor_get(x_64, 1); +lean_inc(x_91); +if (lean_is_exclusive(x_64)) { + lean_ctor_release(x_64, 0); + lean_ctor_release(x_64, 1); + x_92 = x_64; +} else { + lean_dec_ref(x_64); + x_92 = lean_box(0); +} +if (lean_is_scalar(x_92)) { + x_93 = lean_alloc_ctor(1, 2, 0); +} else { + x_93 = x_92; +} +lean_ctor_set(x_93, 0, x_90); +lean_ctor_set(x_93, 1, x_91); +x_94 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_94, 0, x_93); +lean_ctor_set(x_94, 1, x_89); +x_10 = x_94; +x_11 = x_82; +goto block_61; +} +} +} +else +{ +uint8_t x_95; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_95 = !lean_is_exclusive(x_62); +if (x_95 == 0) +{ +return x_62; +} +else +{ +lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_96 = lean_ctor_get(x_62, 0); +x_97 = lean_ctor_get(x_62, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_62); +x_98 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set(x_98, 1, x_97); +return x_98; +} +} +block_61: +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +uint8_t x_13; +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; uint8_t x_16; +x_14 = lean_ctor_get(x_10, 1); +x_15 = lean_ctor_get(x_10, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; +x_17 = lean_ctor_get(x_12, 0); +x_18 = lean_ctor_get(x_12, 1); +x_19 = l_Lake_BuildInfo_key(x_9); +x_20 = l_Lake_BuildKey_toSimpleString(x_19); +x_21 = lean_ctor_get(x_17, 1); +lean_inc(x_21); +x_22 = l_String_isEmpty(x_21); +lean_dec(x_21); +if (x_22 == 0) +{ +lean_object* x_23; +lean_dec(x_20); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_23 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_23, 0, x_10); +lean_ctor_set(x_23, 1, x_11); +return x_23; +} +else +{ +lean_object* x_24; +lean_free_object(x_12); +lean_free_object(x_10); +x_24 = l_Lake_registerJob___rarg(x_20, x_17, x_2, x_3, x_4, x_18, x_14, x_11); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_24; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; +x_25 = lean_ctor_get(x_12, 0); +x_26 = lean_ctor_get(x_12, 1); +lean_inc(x_26); +lean_inc(x_25); +lean_dec(x_12); +x_27 = l_Lake_BuildInfo_key(x_9); +x_28 = l_Lake_BuildKey_toSimpleString(x_27); +x_29 = lean_ctor_get(x_25, 1); +lean_inc(x_29); +x_30 = l_String_isEmpty(x_29); +lean_dec(x_29); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; +lean_dec(x_28); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_25); +lean_ctor_set(x_31, 1, x_26); +lean_ctor_set(x_10, 0, x_31); +x_32 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_32, 0, x_10); +lean_ctor_set(x_32, 1, x_11); +return x_32; +} +else +{ +lean_object* x_33; +lean_free_object(x_10); +x_33 = l_Lake_registerJob___rarg(x_28, x_25, x_2, x_3, x_4, x_26, x_14, x_11); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_33; +} +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; +x_34 = lean_ctor_get(x_10, 1); +lean_inc(x_34); +lean_dec(x_10); +x_35 = lean_ctor_get(x_12, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_12, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_37 = x_12; +} else { + lean_dec_ref(x_12); + x_37 = lean_box(0); +} +x_38 = l_Lake_BuildInfo_key(x_9); +x_39 = l_Lake_BuildKey_toSimpleString(x_38); +x_40 = lean_ctor_get(x_35, 1); +lean_inc(x_40); +x_41 = l_String_isEmpty(x_40); +lean_dec(x_40); +if (x_41 == 0) +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; +lean_dec(x_39); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +if (lean_is_scalar(x_37)) { + x_42 = lean_alloc_ctor(0, 2, 0); +} else { + x_42 = x_37; +} +lean_ctor_set(x_42, 0, x_35); +lean_ctor_set(x_42, 1, x_36); +x_43 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_43, 0, x_42); +lean_ctor_set(x_43, 1, x_34); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_43); +lean_ctor_set(x_44, 1, x_11); +return x_44; +} +else +{ +lean_object* x_45; +lean_dec(x_37); +x_45 = l_Lake_registerJob___rarg(x_39, x_35, x_2, x_3, x_4, x_36, x_34, x_11); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +return x_45; +} +} +} +else +{ +uint8_t x_46; +lean_dec(x_9); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_46 = !lean_is_exclusive(x_10); +if (x_46 == 0) +{ +lean_object* x_47; uint8_t x_48; +x_47 = lean_ctor_get(x_10, 0); +lean_dec(x_47); +x_48 = !lean_is_exclusive(x_12); +if (x_48 == 0) +{ +lean_object* x_49; +x_49 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_49, 0, x_10); +lean_ctor_set(x_49, 1, x_11); +return x_49; +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_50 = lean_ctor_get(x_12, 0); +x_51 = lean_ctor_get(x_12, 1); +lean_inc(x_51); +lean_inc(x_50); +lean_dec(x_12); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_50); +lean_ctor_set(x_52, 1, x_51); +lean_ctor_set(x_10, 0, x_52); +x_53 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_53, 0, x_10); +lean_ctor_set(x_53, 1, x_11); +return x_53; +} +} +else +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_54 = lean_ctor_get(x_10, 1); +lean_inc(x_54); +lean_dec(x_10); +x_55 = lean_ctor_get(x_12, 0); +lean_inc(x_55); +x_56 = lean_ctor_get(x_12, 1); +lean_inc(x_56); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_57 = x_12; +} else { + lean_dec_ref(x_12); + x_57 = lean_box(0); +} +if (lean_is_scalar(x_57)) { + x_58 = lean_alloc_ctor(1, 2, 0); +} else { + x_58 = x_57; +} +lean_ctor_set(x_58, 0, x_55); +lean_ctor_set(x_58, 1, x_56); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_58); +lean_ctor_set(x_59, 1, x_54); +x_60 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_60, 0, x_59); +lean_ctor_set(x_60, 1, x_11); +return x_60; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildSpecs___spec__1(size_t x_1, size_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +uint8_t x_10; +x_10 = lean_usize_dec_lt(x_2, x_1); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_3); +lean_ctor_set(x_11, 1, x_7); +x_12 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_8); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_9); +return x_13; +} +else +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_97; +x_14 = lean_array_uget(x_3, x_2); +x_15 = lean_unsigned_to_nat(0u); +x_16 = lean_array_uset(x_3, x_2, x_15); +x_43 = lean_ctor_get(x_14, 1); +lean_inc(x_43); +x_44 = lean_ctor_get(x_14, 0); +lean_inc(x_44); +lean_dec(x_14); +lean_inc(x_4); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_44); +x_97 = lean_apply_6(x_4, x_44, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_97) == 0) +{ +lean_object* x_98; lean_object* x_99; +x_98 = lean_ctor_get(x_97, 0); +lean_inc(x_98); +x_99 = lean_ctor_get(x_98, 0); +lean_inc(x_99); +if (lean_obj_tag(x_99) == 0) +{ +lean_object* x_100; uint8_t x_101; +x_100 = lean_ctor_get(x_97, 1); +lean_inc(x_100); +lean_dec(x_97); +x_101 = !lean_is_exclusive(x_98); +if (x_101 == 0) +{ +lean_object* x_102; uint8_t x_103; +x_102 = lean_ctor_get(x_98, 0); +lean_dec(x_102); +x_103 = !lean_is_exclusive(x_99); +if (x_103 == 0) +{ +lean_object* x_104; lean_object* x_105; +x_104 = lean_ctor_get(x_99, 0); +x_105 = lean_apply_1(x_43, x_104); +lean_ctor_set(x_99, 0, x_105); +x_45 = x_98; +x_46 = x_100; +goto block_96; +} +else +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_106 = lean_ctor_get(x_99, 0); +x_107 = lean_ctor_get(x_99, 1); +lean_inc(x_107); +lean_inc(x_106); +lean_dec(x_99); +x_108 = lean_apply_1(x_43, x_106); +x_109 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_109, 0, x_108); +lean_ctor_set(x_109, 1, x_107); +lean_ctor_set(x_98, 0, x_109); +x_45 = x_98; +x_46 = x_100; +goto block_96; +} +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_110 = lean_ctor_get(x_98, 1); +lean_inc(x_110); +lean_dec(x_98); +x_111 = lean_ctor_get(x_99, 0); +lean_inc(x_111); +x_112 = lean_ctor_get(x_99, 1); +lean_inc(x_112); +if (lean_is_exclusive(x_99)) { + lean_ctor_release(x_99, 0); + lean_ctor_release(x_99, 1); + x_113 = x_99; +} else { + lean_dec_ref(x_99); + x_113 = lean_box(0); +} +x_114 = lean_apply_1(x_43, x_111); +if (lean_is_scalar(x_113)) { + x_115 = lean_alloc_ctor(0, 2, 0); +} else { + x_115 = x_113; +} +lean_ctor_set(x_115, 0, x_114); +lean_ctor_set(x_115, 1, x_112); +x_116 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_116, 0, x_115); +lean_ctor_set(x_116, 1, x_110); +x_45 = x_116; +x_46 = x_100; +goto block_96; +} +} +else +{ +lean_object* x_117; uint8_t x_118; +lean_dec(x_43); +x_117 = lean_ctor_get(x_97, 1); +lean_inc(x_117); +lean_dec(x_97); +x_118 = !lean_is_exclusive(x_98); +if (x_118 == 0) +{ +lean_object* x_119; uint8_t x_120; +x_119 = lean_ctor_get(x_98, 0); +lean_dec(x_119); +x_120 = !lean_is_exclusive(x_99); +if (x_120 == 0) +{ +x_45 = x_98; +x_46 = x_117; +goto block_96; +} +else +{ +lean_object* x_121; lean_object* x_122; lean_object* x_123; +x_121 = lean_ctor_get(x_99, 0); +x_122 = lean_ctor_get(x_99, 1); +lean_inc(x_122); +lean_inc(x_121); +lean_dec(x_99); +x_123 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_123, 0, x_121); +lean_ctor_set(x_123, 1, x_122); +lean_ctor_set(x_98, 0, x_123); +x_45 = x_98; +x_46 = x_117; +goto block_96; +} +} +else +{ +lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; +x_124 = lean_ctor_get(x_98, 1); +lean_inc(x_124); +lean_dec(x_98); +x_125 = lean_ctor_get(x_99, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_99, 1); +lean_inc(x_126); +if (lean_is_exclusive(x_99)) { + lean_ctor_release(x_99, 0); + lean_ctor_release(x_99, 1); + x_127 = x_99; +} else { + lean_dec_ref(x_99); + x_127 = lean_box(0); +} +if (lean_is_scalar(x_127)) { + x_128 = lean_alloc_ctor(1, 2, 0); +} else { + x_128 = x_127; +} +lean_ctor_set(x_128, 0, x_125); +lean_ctor_set(x_128, 1, x_126); +x_129 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_129, 0, x_128); +lean_ctor_set(x_129, 1, x_124); +x_45 = x_129; +x_46 = x_117; +goto block_96; +} +} +} +else +{ +uint8_t x_130; +lean_dec(x_44); +lean_dec(x_43); +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_130 = !lean_is_exclusive(x_97); +if (x_130 == 0) +{ +return x_97; +} +else +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; +x_131 = lean_ctor_get(x_97, 0); +x_132 = lean_ctor_get(x_97, 1); +lean_inc(x_132); +lean_inc(x_131); +lean_dec(x_97); +x_133 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_133, 0, x_131); +lean_ctor_set(x_133, 1, x_132); +return x_133; +} +} +block_42: +{ +lean_object* x_19; +x_19 = lean_ctor_get(x_17, 0); +lean_inc(x_19); +if (lean_obj_tag(x_19) == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; size_t x_23; size_t x_24; lean_object* x_25; +x_20 = lean_ctor_get(x_17, 1); +lean_inc(x_20); +lean_dec(x_17); +x_21 = lean_ctor_get(x_19, 0); +lean_inc(x_21); +x_22 = lean_ctor_get(x_19, 1); +lean_inc(x_22); +lean_dec(x_19); +x_23 = 1; +x_24 = lean_usize_add(x_2, x_23); +x_25 = lean_array_uset(x_16, x_2, x_21); +x_2 = x_24; +x_3 = x_25; +x_7 = x_22; +x_8 = x_20; +x_9 = x_18; +goto _start; +} +else +{ +uint8_t x_27; +lean_dec(x_16); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_27 = !lean_is_exclusive(x_17); +if (x_27 == 0) +{ +lean_object* x_28; uint8_t x_29; +x_28 = lean_ctor_get(x_17, 0); +lean_dec(x_28); +x_29 = !lean_is_exclusive(x_19); +if (x_29 == 0) +{ +lean_object* x_30; +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_17); +lean_ctor_set(x_30, 1, x_18); +return x_30; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_31 = lean_ctor_get(x_19, 0); +x_32 = lean_ctor_get(x_19, 1); +lean_inc(x_32); +lean_inc(x_31); +lean_dec(x_19); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +lean_ctor_set(x_17, 0, x_33); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_17); +lean_ctor_set(x_34, 1, x_18); +return x_34; +} +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_35 = lean_ctor_get(x_17, 1); +lean_inc(x_35); +lean_dec(x_17); +x_36 = lean_ctor_get(x_19, 0); +lean_inc(x_36); +x_37 = lean_ctor_get(x_19, 1); +lean_inc(x_37); +if (lean_is_exclusive(x_19)) { + lean_ctor_release(x_19, 0); + lean_ctor_release(x_19, 1); + x_38 = x_19; +} else { + lean_dec_ref(x_19); + x_38 = lean_box(0); +} +if (lean_is_scalar(x_38)) { + x_39 = lean_alloc_ctor(1, 2, 0); +} else { + x_39 = x_38; +} +lean_ctor_set(x_39, 0, x_36); +lean_ctor_set(x_39, 1, x_37); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_35); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_18); +return x_41; +} +} +} +block_96: +{ +lean_object* x_47; +x_47 = lean_ctor_get(x_45, 0); +lean_inc(x_47); +if (lean_obj_tag(x_47) == 0) +{ +uint8_t x_48; +x_48 = !lean_is_exclusive(x_45); +if (x_48 == 0) +{ +lean_object* x_49; lean_object* x_50; uint8_t x_51; +x_49 = lean_ctor_get(x_45, 1); +x_50 = lean_ctor_get(x_45, 0); +lean_dec(x_50); +x_51 = !lean_is_exclusive(x_47); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; +x_52 = lean_ctor_get(x_47, 0); +x_53 = lean_ctor_get(x_47, 1); +x_54 = l_Lake_BuildInfo_key(x_44); +x_55 = l_Lake_BuildKey_toSimpleString(x_54); +x_56 = lean_ctor_get(x_52, 1); +lean_inc(x_56); +x_57 = l_String_isEmpty(x_56); +lean_dec(x_56); +if (x_57 == 0) +{ +lean_dec(x_55); +x_17 = x_45; +x_18 = x_46; +goto block_42; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; +lean_free_object(x_47); +lean_free_object(x_45); +x_58 = l_Lake_registerJob___rarg(x_55, x_52, x_4, x_5, x_6, x_53, x_49, x_46); +x_59 = lean_ctor_get(x_58, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_58, 1); +lean_inc(x_60); +lean_dec(x_58); +x_17 = x_59; +x_18 = x_60; +goto block_42; +} +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; +x_61 = lean_ctor_get(x_47, 0); +x_62 = lean_ctor_get(x_47, 1); +lean_inc(x_62); +lean_inc(x_61); +lean_dec(x_47); +x_63 = l_Lake_BuildInfo_key(x_44); +x_64 = l_Lake_BuildKey_toSimpleString(x_63); +x_65 = lean_ctor_get(x_61, 1); +lean_inc(x_65); +x_66 = l_String_isEmpty(x_65); +lean_dec(x_65); +if (x_66 == 0) +{ +lean_object* x_67; +lean_dec(x_64); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_61); +lean_ctor_set(x_67, 1, x_62); +lean_ctor_set(x_45, 0, x_67); +x_17 = x_45; +x_18 = x_46; +goto block_42; +} +else +{ +lean_object* x_68; lean_object* x_69; lean_object* x_70; +lean_free_object(x_45); +x_68 = l_Lake_registerJob___rarg(x_64, x_61, x_4, x_5, x_6, x_62, x_49, x_46); +x_69 = lean_ctor_get(x_68, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_68, 1); +lean_inc(x_70); +lean_dec(x_68); +x_17 = x_69; +x_18 = x_70; +goto block_42; +} +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; +x_71 = lean_ctor_get(x_45, 1); +lean_inc(x_71); +lean_dec(x_45); +x_72 = lean_ctor_get(x_47, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_47, 1); +lean_inc(x_73); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_74 = x_47; +} else { + lean_dec_ref(x_47); + x_74 = lean_box(0); +} +x_75 = l_Lake_BuildInfo_key(x_44); +x_76 = l_Lake_BuildKey_toSimpleString(x_75); +x_77 = lean_ctor_get(x_72, 1); +lean_inc(x_77); +x_78 = l_String_isEmpty(x_77); +lean_dec(x_77); +if (x_78 == 0) +{ +lean_object* x_79; lean_object* x_80; +lean_dec(x_76); +if (lean_is_scalar(x_74)) { + x_79 = lean_alloc_ctor(0, 2, 0); +} else { + x_79 = x_74; +} +lean_ctor_set(x_79, 0, x_72); +lean_ctor_set(x_79, 1, x_73); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_71); +x_17 = x_80; +x_18 = x_46; +goto block_42; +} +else +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_dec(x_74); +x_81 = l_Lake_registerJob___rarg(x_76, x_72, x_4, x_5, x_6, x_73, x_71, x_46); +x_82 = lean_ctor_get(x_81, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_81, 1); +lean_inc(x_83); +lean_dec(x_81); +x_17 = x_82; +x_18 = x_83; +goto block_42; +} +} +} +else +{ +uint8_t x_84; +lean_dec(x_44); +x_84 = !lean_is_exclusive(x_45); +if (x_84 == 0) +{ +lean_object* x_85; uint8_t x_86; +x_85 = lean_ctor_get(x_45, 0); +lean_dec(x_85); +x_86 = !lean_is_exclusive(x_47); +if (x_86 == 0) +{ +x_17 = x_45; +x_18 = x_46; +goto block_42; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_47, 0); +x_88 = lean_ctor_get(x_47, 1); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_47); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +lean_ctor_set(x_45, 0, x_89); +x_17 = x_45; +x_18 = x_46; +goto block_42; +} +} +else +{ +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_90 = lean_ctor_get(x_45, 1); +lean_inc(x_90); +lean_dec(x_45); +x_91 = lean_ctor_get(x_47, 0); +lean_inc(x_91); +x_92 = lean_ctor_get(x_47, 1); +lean_inc(x_92); +if (lean_is_exclusive(x_47)) { + lean_ctor_release(x_47, 0); + lean_ctor_release(x_47, 1); + x_93 = x_47; +} else { + lean_dec_ref(x_47); + x_93 = lean_box(0); +} +if (lean_is_scalar(x_93)) { + x_94 = lean_alloc_ctor(1, 2, 0); +} else { + x_94 = x_93; +} +lean_ctor_set(x_94, 0, x_91); +lean_ctor_set(x_94, 1, x_92); +x_95 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_90); +x_17 = x_95; +x_18 = x_46; +goto block_42; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_buildSpecs(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { +_start: +{ +lean_object* x_8; size_t x_9; size_t x_10; lean_object* x_11; +x_8 = lean_array_get_size(x_1); +x_9 = lean_usize_of_nat(x_8); +lean_dec(x_8); +x_10 = 0; +x_11 = l_Array_mapMUnsafe_map___at_Lake_buildSpecs___spec__1(x_9, x_10, x_1, x_2, x_3, x_4, x_5, x_6, x_7); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +x_13 = lean_ctor_get(x_12, 0); +lean_inc(x_13); +if (lean_obj_tag(x_13) == 0) +{ +uint8_t x_14; +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; uint8_t x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_dec(x_15); +x_16 = !lean_is_exclusive(x_12); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_ctor_get(x_12, 0); +lean_dec(x_17); +x_18 = !lean_is_exclusive(x_13); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; +x_19 = lean_ctor_get(x_13, 0); +x_20 = l_Lake_BuildJob_mixArray___rarg(x_19); +lean_dec(x_19); +lean_ctor_set(x_13, 0, x_20); +return x_11; +} +else +{ +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_13, 0); +x_22 = lean_ctor_get(x_13, 1); +lean_inc(x_22); +lean_inc(x_21); +lean_dec(x_13); +x_23 = l_Lake_BuildJob_mixArray___rarg(x_21); +lean_dec(x_21); +x_24 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_22); +lean_ctor_set(x_12, 0, x_24); +return x_11; +} +} +else +{ +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_25 = lean_ctor_get(x_12, 1); +lean_inc(x_25); +lean_dec(x_12); +x_26 = lean_ctor_get(x_13, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_13, 1); +lean_inc(x_27); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_28 = x_13; +} else { + lean_dec_ref(x_13); + x_28 = lean_box(0); +} +x_29 = l_Lake_BuildJob_mixArray___rarg(x_26); +lean_dec(x_26); +if (lean_is_scalar(x_28)) { + x_30 = lean_alloc_ctor(0, 2, 0); +} else { + x_30 = x_28; +} +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_25); +lean_ctor_set(x_11, 0, x_31); +return x_11; +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_32 = lean_ctor_get(x_11, 1); +lean_inc(x_32); +lean_dec(x_11); +x_33 = lean_ctor_get(x_12, 1); +lean_inc(x_33); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_34 = x_12; +} else { + lean_dec_ref(x_12); + x_34 = lean_box(0); +} +x_35 = lean_ctor_get(x_13, 0); +lean_inc(x_35); +x_36 = lean_ctor_get(x_13, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_37 = x_13; +} else { + lean_dec_ref(x_13); + x_37 = lean_box(0); +} +x_38 = l_Lake_BuildJob_mixArray___rarg(x_35); +lean_dec(x_35); +if (lean_is_scalar(x_37)) { + x_39 = lean_alloc_ctor(0, 2, 0); +} else { + x_39 = x_37; +} +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_36); +if (lean_is_scalar(x_34)) { + x_40 = lean_alloc_ctor(0, 2, 0); +} else { + x_40 = x_34; +} +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_33); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_32); +return x_41; +} +} +else +{ +uint8_t x_42; +x_42 = !lean_is_exclusive(x_11); +if (x_42 == 0) +{ +lean_object* x_43; uint8_t x_44; +x_43 = lean_ctor_get(x_11, 0); +lean_dec(x_43); +x_44 = !lean_is_exclusive(x_12); +if (x_44 == 0) +{ +lean_object* x_45; uint8_t x_46; +x_45 = lean_ctor_get(x_12, 0); +lean_dec(x_45); +x_46 = !lean_is_exclusive(x_13); +if (x_46 == 0) +{ +return x_11; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_13, 0); +x_48 = lean_ctor_get(x_13, 1); +lean_inc(x_48); +lean_inc(x_47); +lean_dec(x_13); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +lean_ctor_set(x_12, 0, x_49); +return x_11; +} +} +else +{ +lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_50 = lean_ctor_get(x_12, 1); +lean_inc(x_50); +lean_dec(x_12); +x_51 = lean_ctor_get(x_13, 0); +lean_inc(x_51); +x_52 = lean_ctor_get(x_13, 1); +lean_inc(x_52); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_53 = x_13; +} else { + lean_dec_ref(x_13); + x_53 = lean_box(0); +} +if (lean_is_scalar(x_53)) { + x_54 = lean_alloc_ctor(1, 2, 0); +} else { + x_54 = x_53; +} +lean_ctor_set(x_54, 0, x_51); +lean_ctor_set(x_54, 1, x_52); +x_55 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_55, 0, x_54); +lean_ctor_set(x_55, 1, x_50); +lean_ctor_set(x_11, 0, x_55); +return x_11; +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_56 = lean_ctor_get(x_11, 1); +lean_inc(x_56); +lean_dec(x_11); +x_57 = lean_ctor_get(x_12, 1); +lean_inc(x_57); +if (lean_is_exclusive(x_12)) { + lean_ctor_release(x_12, 0); + lean_ctor_release(x_12, 1); + x_58 = x_12; +} else { + lean_dec_ref(x_12); + x_58 = lean_box(0); +} +x_59 = lean_ctor_get(x_13, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_13, 1); +lean_inc(x_60); +if (lean_is_exclusive(x_13)) { + lean_ctor_release(x_13, 0); + lean_ctor_release(x_13, 1); + x_61 = x_13; +} else { + lean_dec_ref(x_13); + x_61 = lean_box(0); +} +if (lean_is_scalar(x_61)) { + x_62 = lean_alloc_ctor(1, 2, 0); +} else { + x_62 = x_61; +} +lean_ctor_set(x_62, 0, x_59); +lean_ctor_set(x_62, 1, x_60); +if (lean_is_scalar(x_58)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_58; +} +lean_ctor_set(x_63, 0, x_62); +lean_ctor_set(x_63, 1, x_57); +x_64 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_64, 0, x_63); +lean_ctor_set(x_64, 1, x_56); +return x_64; +} +} +} +else +{ +uint8_t x_65; +x_65 = !lean_is_exclusive(x_11); +if (x_65 == 0) +{ +return x_11; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_11, 0); +x_67 = lean_ctor_get(x_11, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_11); +x_68 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +return x_68; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_buildSpecs___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) { +_start: +{ +size_t x_10; size_t x_11; lean_object* x_12; +x_10 = lean_unbox_usize(x_1); +lean_dec(x_1); +x_11 = lean_unbox_usize(x_2); +lean_dec(x_2); +x_12 = l_Array_mapMUnsafe_map___at_Lake_buildSpecs___spec__1(x_10, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +return x_12; +} +} +LEAN_EXPORT lean_object* l_Lake_parsePackageSpec(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = l_String_isEmpty(x_2); +if (x_3 == 0) +{ +lean_object* x_4; lean_object* x_5; lean_object* x_6; +lean_inc(x_2); +x_4 = l_Lake_stringToLegalOrSimpleName(x_2); +x_5 = lean_ctor_get(x_1, 3); +x_6 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(x_5, x_4); +lean_dec(x_4); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; lean_object* x_8; +x_7 = lean_alloc_ctor(10, 1, 0); +lean_ctor_set(x_7, 0, x_2); +x_8 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; +} +else +{ +uint8_t x_9; +lean_dec(x_2); +x_9 = !lean_is_exclusive(x_6); +if (x_9 == 0) +{ +return x_6; +} +else +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_6, 0); +lean_inc(x_10); +lean_dec(x_6); +x_11 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_11, 0, x_10); +return x_11; +} +} +} +else +{ +lean_object* x_12; lean_object* x_13; +lean_dec(x_2); +x_12 = lean_ctor_get(x_1, 0); +lean_inc(x_12); +x_13 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_13, 0, x_12); +return x_13; +} +} +} +LEAN_EXPORT lean_object* l_Lake_parsePackageSpec___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_parsePackageSpec(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_resolveModuleTarget___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("module", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveModuleTarget___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("leanArts", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveModuleTarget___closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_resolveModuleTarget___closed__2; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveModuleTarget(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = l_Lean_Name_isAnonymous(x_3); +if (x_4 == 0) +{ +lean_object* x_5; +x_5 = l_Lake_Workspace_findModuleFacetConfig_x3f(x_3, x_1); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +lean_dec(x_2); +x_6 = l_Lake_resolveModuleTarget___closed__1; +x_7 = lean_alloc_ctor(11, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +x_8 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; +} +else +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_5); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_5, 0); +x_11 = lean_ctor_get(x_10, 1); +lean_inc(x_11); +lean_dec(x_10); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; +lean_dec(x_2); +x_12 = l_Lake_resolveModuleTarget___closed__1; +x_13 = lean_alloc_ctor(16, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_3); +lean_ctor_set_tag(x_5, 0); +lean_ctor_set(x_5, 0, x_13); +return x_5; +} +else +{ +uint8_t x_14; +lean_free_object(x_5); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; +x_15 = lean_ctor_get(x_11, 0); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_2); +lean_ctor_set(x_16, 1, x_3); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +lean_ctor_set(x_11, 0, x_17); +return x_11; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_11, 0); +lean_inc(x_18); +lean_dec(x_11); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_2); +lean_ctor_set(x_19, 1, x_3); +x_20 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_20, 0, x_19); +lean_ctor_set(x_20, 1, x_18); +x_21 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_21, 0, x_20); +return x_21; +} +} +} +else +{ +lean_object* x_22; lean_object* x_23; +x_22 = lean_ctor_get(x_5, 0); +lean_inc(x_22); +lean_dec(x_5); +x_23 = lean_ctor_get(x_22, 1); +lean_inc(x_23); +lean_dec(x_22); +if (lean_obj_tag(x_23) == 0) +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; +lean_dec(x_2); +x_24 = l_Lake_resolveModuleTarget___closed__1; +x_25 = lean_alloc_ctor(16, 2, 0); +lean_ctor_set(x_25, 0, x_24); +lean_ctor_set(x_25, 1, x_3); +x_26 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_26, 0, x_25); +return x_26; +} +else +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_27 = lean_ctor_get(x_23, 0); +lean_inc(x_27); +if (lean_is_exclusive(x_23)) { + lean_ctor_release(x_23, 0); + x_28 = x_23; +} else { + lean_dec_ref(x_23); + x_28 = lean_box(0); +} +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_2); +lean_ctor_set(x_29, 1, x_3); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_27); +if (lean_is_scalar(x_28)) { + x_31 = lean_alloc_ctor(1, 1, 0); +} else { + x_31 = x_28; +} +lean_ctor_set(x_31, 0, x_30); +return x_31; +} +} +} +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_3); +x_32 = l_Lake_resolveModuleTarget___closed__3; +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_2); +lean_ctor_set(x_33, 1, x_32); +x_34 = l_Lake_mkBuildSpec___rarg___closed__1; +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +x_36 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_36, 0, x_35); +return x_36; +} +} +} +LEAN_EXPORT lean_object* l_Lake_resolveModuleTarget___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_resolveModuleTarget(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +static lean_object* _init_l_Lake_resolveLibTarget_resolveFacet___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("library", 7); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget_resolveFacet(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_Workspace_findLibraryFacetConfig_x3f(x_3, x_1); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +lean_dec(x_2); +x_5 = l_Lake_resolveLibTarget_resolveFacet___closed__1; +x_6 = lean_alloc_ctor(11, 2, 0); +lean_ctor_set(x_6, 0, x_5); +lean_ctor_set(x_6, 1, x_3); +x_7 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_7, 0, x_6); +return x_7; +} +else +{ +uint8_t x_8; +x_8 = !lean_is_exclusive(x_4); +if (x_8 == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_4, 0); +x_10 = lean_ctor_get(x_9, 1); +lean_inc(x_10); +lean_dec(x_9); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +lean_dec(x_2); +x_11 = l_Lake_resolveLibTarget_resolveFacet___closed__1; +x_12 = lean_alloc_ctor(16, 2, 0); +lean_ctor_set(x_12, 0, x_11); +lean_ctor_set(x_12, 1, x_3); +lean_ctor_set_tag(x_4, 0); +lean_ctor_set(x_4, 0, x_12); +return x_4; +} +else +{ +uint8_t x_13; +lean_free_object(x_4); +x_13 = !lean_is_exclusive(x_10); +if (x_13 == 0) +{ +lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_14 = lean_ctor_get(x_10, 0); +x_15 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_15, 0, x_2); +lean_ctor_set(x_15, 1, x_3); +x_16 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_16, 0, x_15); +lean_ctor_set(x_16, 1, x_14); +lean_ctor_set(x_10, 0, x_16); +return x_10; +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_17 = lean_ctor_get(x_10, 0); +lean_inc(x_17); +lean_dec(x_10); +x_18 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_18, 0, x_2); +lean_ctor_set(x_18, 1, x_3); +x_19 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_19, 0, x_18); +lean_ctor_set(x_19, 1, x_17); +x_20 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_20, 0, x_19); +return x_20; +} +} +} +else +{ +lean_object* x_21; lean_object* x_22; +x_21 = lean_ctor_get(x_4, 0); +lean_inc(x_21); +lean_dec(x_4); +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +if (lean_obj_tag(x_22) == 0) +{ +lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_dec(x_2); +x_23 = l_Lake_resolveLibTarget_resolveFacet___closed__1; +x_24 = lean_alloc_ctor(16, 2, 0); +lean_ctor_set(x_24, 0, x_23); +lean_ctor_set(x_24, 1, x_3); +x_25 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_25, 0, x_24); +return x_25; +} +else +{ +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_26 = lean_ctor_get(x_22, 0); +lean_inc(x_26); +if (lean_is_exclusive(x_22)) { + lean_ctor_release(x_22, 0); + x_27 = x_22; +} else { + lean_dec_ref(x_22); + x_27 = lean_box(0); +} +x_28 = lean_alloc_ctor(2, 2, 0); +lean_ctor_set(x_28, 0, x_2); +lean_ctor_set(x_28, 1, x_3); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_26); +if (lean_is_scalar(x_27)) { + x_30 = lean_alloc_ctor(1, 1, 0); +} else { + x_30 = x_27; +} +lean_ctor_set(x_30, 0, x_29); +return x_30; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget_resolveFacet___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_resolveLibTarget_resolveFacet(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_resolveLibTarget___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, size_t x_4, lean_object* x_5) { +_start: +{ +uint8_t x_6; +x_6 = lean_usize_dec_lt(x_4, x_3); +if (x_6 == 0) +{ +lean_object* x_7; +lean_dec(x_2); +x_7 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_7, 0, x_5); +return x_7; +} +else +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_8 = lean_array_uget(x_5, x_4); +x_9 = lean_unsigned_to_nat(0u); +x_10 = lean_array_uset(x_5, x_4, x_9); +lean_inc(x_2); +x_11 = l_Lake_resolveLibTarget_resolveFacet(x_1, x_2, x_8); +if (lean_obj_tag(x_11) == 0) +{ +uint8_t x_12; +lean_dec(x_10); +lean_dec(x_2); +x_12 = !lean_is_exclusive(x_11); +if (x_12 == 0) +{ +return x_11; +} +else +{ +lean_object* x_13; lean_object* x_14; +x_13 = lean_ctor_get(x_11, 0); +lean_inc(x_13); +lean_dec(x_11); +x_14 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_14, 0, x_13); +return x_14; +} +} +else +{ +lean_object* x_15; size_t x_16; size_t x_17; lean_object* x_18; +x_15 = lean_ctor_get(x_11, 0); +lean_inc(x_15); +lean_dec(x_11); +x_16 = 1; +x_17 = lean_usize_add(x_4, x_16); +x_18 = lean_array_uset(x_10, x_4, x_15); +x_4 = x_17; +x_5 = x_18; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = l_Lean_Name_isAnonymous(x_3); +if (x_4 == 0) +{ +lean_object* x_5; +x_5 = l_Lake_resolveLibTarget_resolveFacet(x_1, x_2, x_3); +if (lean_obj_tag(x_5) == 0) +{ +uint8_t x_6; +x_6 = !lean_is_exclusive(x_5); +if (x_6 == 0) +{ +return x_5; +} +else +{ +lean_object* x_7; lean_object* x_8; +x_7 = lean_ctor_get(x_5, 0); +lean_inc(x_7); +lean_dec(x_5); +x_8 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; +} +} +else +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_5); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_10 = lean_ctor_get(x_5, 0); +x_11 = lean_unsigned_to_nat(1u); +x_12 = lean_mk_array(x_11, x_10); +lean_ctor_set(x_5, 0, x_12); +return x_5; +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_13 = lean_ctor_get(x_5, 0); +lean_inc(x_13); +lean_dec(x_5); +x_14 = lean_unsigned_to_nat(1u); +x_15 = lean_mk_array(x_14, x_13); +x_16 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_16, 0, x_15); +return x_16; +} +} +} +else +{ +lean_object* x_17; lean_object* x_18; lean_object* x_19; size_t x_20; size_t x_21; lean_object* x_22; +lean_dec(x_3); +x_17 = lean_ctor_get(x_2, 1); +lean_inc(x_17); +x_18 = lean_ctor_get(x_17, 7); +lean_inc(x_18); +lean_dec(x_17); +x_19 = lean_array_get_size(x_18); +x_20 = lean_usize_of_nat(x_19); +lean_dec(x_19); +x_21 = 0; +x_22 = l_Array_mapMUnsafe_map___at_Lake_resolveLibTarget___spec__1(x_1, x_2, x_20, x_21, x_18); +return x_22; +} +} +} +LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lake_resolveLibTarget___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +_start: +{ +size_t x_6; size_t x_7; lean_object* x_8; +x_6 = lean_unbox_usize(x_3); +lean_dec(x_3); +x_7 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_8 = l_Array_mapMUnsafe_map___at_Lake_resolveLibTarget___spec__1(x_1, x_2, x_6, x_7, x_5); +lean_dec(x_1); +return x_8; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveLibTarget___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_resolveLibTarget(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +static lean_object* _init_l_Lake_resolveExeTarget___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("exe", 3); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveExeTarget___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_resolveExeTarget___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_resolveExeTarget___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("executable", 10); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveExeTarget(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = l_Lean_Name_isAnonymous(x_2); +if (x_3 == 0) +{ +lean_object* x_4; uint8_t x_5; +x_4 = l_Lake_resolveExeTarget___closed__2; +x_5 = lean_name_eq(x_2, x_4); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +lean_dec(x_1); +x_6 = l_Lake_resolveExeTarget___closed__3; +x_7 = lean_alloc_ctor(11, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_2); +x_8 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; +} +else +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +lean_dec(x_2); +x_9 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_9, 0, x_1); +x_10 = l_Lake_mkBuildSpec___rarg___closed__1; +x_11 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_11, 0, x_9); +lean_ctor_set(x_11, 1, x_10); +x_12 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_12, 0, x_11); +return x_12; +} +} +else +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +lean_dec(x_2); +x_13 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_13, 0, x_1); +x_14 = l_Lake_mkBuildSpec___rarg___closed__1; +x_15 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_14); +x_16 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_16, 0, x_15); +return x_16; +} +} +} +static lean_object* _init_l_Lake_resolveExternLibTarget___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("static", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveExternLibTarget___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_resolveExternLibTarget___closed__1; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_resolveExternLibTarget___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("shared", 6); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveExternLibTarget___closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = lean_box(0); +x_2 = l_Lake_resolveExternLibTarget___closed__3; +x_3 = l_Lean_Name_str___override(x_1, x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_resolveExternLibTarget___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("external library", 16); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveExternLibTarget(lean_object* x_1, lean_object* x_2) { +_start: +{ +uint8_t x_3; +x_3 = l_Lean_Name_isAnonymous(x_2); +if (x_3 == 0) +{ +lean_object* x_4; uint8_t x_5; +x_4 = l_Lake_resolveExternLibTarget___closed__2; +x_5 = lean_name_eq(x_2, x_4); +if (x_5 == 0) +{ +lean_object* x_6; uint8_t x_7; +x_6 = l_Lake_resolveExternLibTarget___closed__4; +x_7 = lean_name_eq(x_2, x_6); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +lean_dec(x_1); +x_8 = l_Lake_resolveExternLibTarget___closed__5; +x_9 = lean_alloc_ctor(11, 2, 0); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_2); +x_10 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_10, 0, x_9); +return x_10; +} +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; +lean_dec(x_2); +x_11 = lean_alloc_ctor(5, 1, 0); +lean_ctor_set(x_11, 0, x_1); +x_12 = l_Lake_mkBuildSpec___rarg___closed__1; +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_11); +lean_ctor_set(x_13, 1, x_12); +x_14 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_14, 0, x_13); +return x_14; +} +} +else +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_dec(x_2); +x_15 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_15, 0, x_1); +x_16 = l_Lake_mkBuildSpec___rarg___closed__1; +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_15); +lean_ctor_set(x_17, 1, x_16); +x_18 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_18, 0, x_17); +return x_18; +} +} +else +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; +lean_dec(x_2); +x_19 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_19, 0, x_1); +x_20 = l_Lake_mkBuildSpec___rarg___closed__1; +x_21 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_21, 0, x_19); +lean_ctor_set(x_21, 1, x_20); +x_22 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_22, 0, x_21); +return x_22; +} +} +} +LEAN_EXPORT lean_object* l_Lake_resolveCustomTarget(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +uint8_t x_5; +x_5 = l_Lean_Name_isAnonymous(x_3); +if (x_5 == 0) +{ +lean_object* x_6; lean_object* x_7; +lean_dec(x_4); +lean_dec(x_1); +x_6 = lean_alloc_ctor(18, 2, 0); +lean_ctor_set(x_6, 0, x_2); +lean_ctor_set(x_6, 1, x_3); +x_7 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_7, 0, x_6); +return x_7; +} +else +{ +lean_object* x_8; uint8_t x_9; +lean_dec(x_3); +x_8 = lean_alloc_ctor(7, 2, 0); +lean_ctor_set(x_8, 0, x_1); +lean_ctor_set(x_8, 1, x_2); +x_9 = !lean_is_exclusive(x_4); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_4, 0); +lean_dec(x_10); +lean_ctor_set(x_4, 0, x_8); +x_11 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_11, 0, x_4); +return x_11; +} +else +{ +lean_object* x_12; lean_object* x_13; lean_object* x_14; +x_12 = lean_ctor_get(x_4, 1); +lean_inc(x_12); +lean_dec(x_4); +x_13 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_13, 0, x_8); +lean_ctor_set(x_13, 1, x_12); +x_14 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_14, 0, x_13); +return x_14; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_resolveTargetInPackage___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; +x_4 = lean_box(0); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; +x_5 = lean_ctor_get(x_2, 0); +x_6 = lean_ctor_get(x_2, 1); +x_7 = lean_ctor_get(x_2, 2); +x_8 = lean_ctor_get(x_2, 3); +x_9 = l_Lean_Name_quickCmp(x_3, x_6); +switch (x_9) { +case 0: +{ +x_2 = x_5; +goto _start; +} +case 1: +{ +lean_object* x_11; +lean_inc(x_7); +x_11 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_11, 0, x_7); +return x_11; +} +default: +{ +x_2 = x_8; +goto _start; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_resolveTargetInPackage(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_Package_findTargetConfig_x3f(x_3, x_2); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +x_6 = lean_ctor_get(x_2, 9); +lean_inc(x_6); +x_7 = lean_ctor_get(x_6, 0); +lean_inc(x_7); +lean_dec(x_6); +x_8 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_7, x_3); +lean_dec(x_7); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_2, 10); +lean_inc(x_9); +x_10 = l_Lake_RBNode_dFind___at_Lake_resolveTargetInPackage___spec__1(x_2, x_9, x_3); +lean_dec(x_9); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; +x_11 = lean_ctor_get(x_2, 8); +lean_inc(x_11); +x_12 = lean_ctor_get(x_11, 0); +lean_inc(x_12); +lean_dec(x_11); +x_13 = l_Lean_RBNode_find___at_Lake_Package_findLeanLib_x3f___spec__1(x_12, x_3); +lean_dec(x_12); +if (lean_obj_tag(x_13) == 0) +{ +lean_object* x_14; +lean_inc(x_2); +lean_inc(x_3); +x_14 = l_Lake_Package_findTargetModule_x3f(x_3, x_2); +if (lean_obj_tag(x_14) == 0) +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_dec(x_4); +x_15 = lean_ctor_get(x_2, 2); +lean_inc(x_15); +lean_dec(x_2); +x_16 = lean_ctor_get(x_15, 2); +lean_inc(x_16); +lean_dec(x_15); +x_17 = 0; +x_18 = l_Lean_Name_toString(x_3, x_17); +x_19 = lean_alloc_ctor(14, 2, 0); +lean_ctor_set(x_19, 0, x_16); +lean_ctor_set(x_19, 1, x_18); +x_20 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_20, 0, x_19); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; +lean_dec(x_3); +lean_dec(x_2); +x_21 = lean_ctor_get(x_14, 0); +lean_inc(x_21); +lean_dec(x_14); +x_22 = l_Lake_resolveModuleTarget(x_1, x_21, x_4); +if (lean_obj_tag(x_22) == 0) +{ +uint8_t x_23; +x_23 = !lean_is_exclusive(x_22); +if (x_23 == 0) +{ +return x_22; +} +else +{ +lean_object* x_24; lean_object* x_25; +x_24 = lean_ctor_get(x_22, 0); +lean_inc(x_24); +lean_dec(x_22); +x_25 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_25, 0, x_24); +return x_25; +} +} +else +{ +uint8_t x_26; +x_26 = !lean_is_exclusive(x_22); +if (x_26 == 0) +{ +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_22, 0); +x_28 = lean_unsigned_to_nat(1u); +x_29 = lean_mk_array(x_28, x_27); +lean_ctor_set(x_22, 0, x_29); +return x_22; +} +else +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_30 = lean_ctor_get(x_22, 0); +lean_inc(x_30); +lean_dec(x_22); +x_31 = lean_unsigned_to_nat(1u); +x_32 = lean_mk_array(x_31, x_30); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +return x_33; +} +} +} +} +else +{ +lean_object* x_34; lean_object* x_35; lean_object* x_36; +lean_dec(x_3); +x_34 = lean_ctor_get(x_13, 0); +lean_inc(x_34); +lean_dec(x_13); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_2); +lean_ctor_set(x_35, 1, x_34); +x_36 = l_Lake_resolveLibTarget(x_1, x_35, x_4); +return x_36; +} +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_10, 0); +lean_inc(x_37); +lean_dec(x_10); +x_38 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_38, 0, x_2); +lean_ctor_set(x_38, 1, x_3); +lean_ctor_set(x_38, 2, x_37); +x_39 = l_Lake_resolveExternLibTarget(x_38, x_4); +if (lean_obj_tag(x_39) == 0) +{ +uint8_t x_40; +x_40 = !lean_is_exclusive(x_39); +if (x_40 == 0) +{ +return x_39; +} +else +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_39, 0); +lean_inc(x_41); +lean_dec(x_39); +x_42 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_42, 0, x_41); +return x_42; +} +} +else +{ +uint8_t x_43; +x_43 = !lean_is_exclusive(x_39); +if (x_43 == 0) +{ +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_39, 0); +x_45 = lean_unsigned_to_nat(1u); +x_46 = lean_mk_array(x_45, x_44); +lean_ctor_set(x_39, 0, x_46); +return x_39; +} +else +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_47 = lean_ctor_get(x_39, 0); +lean_inc(x_47); +lean_dec(x_39); +x_48 = lean_unsigned_to_nat(1u); +x_49 = lean_mk_array(x_48, x_47); +x_50 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_50, 0, x_49); +return x_50; +} +} +} +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; +lean_dec(x_3); +x_51 = lean_ctor_get(x_8, 0); +lean_inc(x_51); +lean_dec(x_8); +x_52 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_52, 0, x_2); +lean_ctor_set(x_52, 1, x_51); +x_53 = l_Lake_resolveExeTarget(x_52, x_4); +if (lean_obj_tag(x_53) == 0) +{ +uint8_t x_54; +x_54 = !lean_is_exclusive(x_53); +if (x_54 == 0) +{ +return x_53; +} +else +{ +lean_object* x_55; lean_object* x_56; +x_55 = lean_ctor_get(x_53, 0); +lean_inc(x_55); +lean_dec(x_53); +x_56 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_56, 0, x_55); +return x_56; +} +} +else +{ +uint8_t x_57; +x_57 = !lean_is_exclusive(x_53); +if (x_57 == 0) +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_53, 0); +x_59 = lean_unsigned_to_nat(1u); +x_60 = lean_mk_array(x_59, x_58); +lean_ctor_set(x_53, 0, x_60); +return x_53; +} +else +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_61 = lean_ctor_get(x_53, 0); +lean_inc(x_61); +lean_dec(x_53); +x_62 = lean_unsigned_to_nat(1u); +x_63 = lean_mk_array(x_62, x_61); +x_64 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_64, 0, x_63); +return x_64; +} +} +} +} +else +{ +lean_object* x_65; lean_object* x_66; +x_65 = lean_ctor_get(x_5, 0); +lean_inc(x_65); +lean_dec(x_5); +x_66 = l_Lake_resolveCustomTarget(x_2, x_3, x_4, x_65); +if (lean_obj_tag(x_66) == 0) +{ +uint8_t x_67; +x_67 = !lean_is_exclusive(x_66); +if (x_67 == 0) +{ +return x_66; +} +else +{ +lean_object* x_68; lean_object* x_69; +x_68 = lean_ctor_get(x_66, 0); +lean_inc(x_68); +lean_dec(x_66); +x_69 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_69, 0, x_68); +return x_69; +} +} +else +{ +uint8_t x_70; +x_70 = !lean_is_exclusive(x_66); +if (x_70 == 0) +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_71 = lean_ctor_get(x_66, 0); +x_72 = lean_unsigned_to_nat(1u); +x_73 = lean_mk_array(x_72, x_71); +lean_ctor_set(x_66, 0, x_73); +return x_66; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_74 = lean_ctor_get(x_66, 0); +lean_inc(x_74); +lean_dec(x_66); +x_75 = lean_unsigned_to_nat(1u); +x_76 = lean_mk_array(x_75, x_74); +x_77 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_77, 0, x_76); +return x_77; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_RBNode_dFind___at_Lake_resolveTargetInPackage___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_RBNode_dFind___at_Lake_resolveTargetInPackage___spec__1(x_1, x_2, x_3); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveTargetInPackage___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { +_start: +{ +lean_object* x_5; +x_5 = l_Lake_resolveTargetInPackage(x_1, x_2, x_3, x_4); +lean_dec(x_1); +return x_5; +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_resolveDefaultPackageTarget___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, size_t x_4, size_t x_5, lean_object* x_6) { +_start: +{ +uint8_t x_7; +x_7 = lean_usize_dec_eq(x_4, x_5); +if (x_7 == 0) +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; +x_8 = lean_array_uget(x_3, x_4); +x_9 = lean_box(0); +lean_inc(x_2); +x_10 = l_Lake_resolveTargetInPackage(x_1, x_2, x_8, x_9); +if (lean_obj_tag(x_10) == 0) +{ +uint8_t x_11; +lean_dec(x_6); +lean_dec(x_2); +x_11 = !lean_is_exclusive(x_10); +if (x_11 == 0) +{ +return x_10; +} +else +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_ctor_get(x_10, 0); +lean_inc(x_12); +lean_dec(x_10); +x_13 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_13, 0, x_12); +return x_13; +} +} +else +{ +lean_object* x_14; lean_object* x_15; size_t x_16; size_t x_17; +x_14 = lean_ctor_get(x_10, 0); +lean_inc(x_14); +lean_dec(x_10); +x_15 = l_Array_append___rarg(x_6, x_14); +lean_dec(x_14); +x_16 = 1; +x_17 = lean_usize_add(x_4, x_16); +x_4 = x_17; +x_6 = x_15; +goto _start; +} +} +else +{ +lean_object* x_19; +lean_dec(x_2); +x_19 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_19, 0, x_6); +return x_19; +} +} +} +static lean_object* _init_l_Lake_resolveDefaultPackageTarget___closed__1() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(0u); +x_2 = lean_mk_empty_array_with_capacity(x_1); +return x_2; +} +} +static lean_object* _init_l_Lake_resolveDefaultPackageTarget___closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l_Lake_resolveDefaultPackageTarget___closed__1; +x_2 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveDefaultPackageTarget(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; +x_3 = lean_ctor_get(x_2, 12); +lean_inc(x_3); +x_4 = lean_array_get_size(x_3); +x_5 = lean_unsigned_to_nat(0u); +x_6 = lean_nat_dec_lt(x_5, x_4); +if (x_6 == 0) +{ +lean_object* x_7; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_7 = l_Lake_resolveDefaultPackageTarget___closed__2; +return x_7; +} +else +{ +uint8_t x_8; +x_8 = lean_nat_dec_le(x_4, x_4); +if (x_8 == 0) +{ +lean_object* x_9; +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +x_9 = l_Lake_resolveDefaultPackageTarget___closed__2; +return x_9; +} +else +{ +size_t x_10; size_t x_11; lean_object* x_12; lean_object* x_13; +x_10 = 0; +x_11 = lean_usize_of_nat(x_4); +lean_dec(x_4); +x_12 = l_Lake_resolveDefaultPackageTarget___closed__1; +x_13 = l_Array_foldlMUnsafe_fold___at_Lake_resolveDefaultPackageTarget___spec__1(x_1, x_2, x_3, x_10, x_11, x_12); +lean_dec(x_3); +return x_13; +} +} +} +} +LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at_Lake_resolveDefaultPackageTarget___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +_start: +{ +size_t x_7; size_t x_8; lean_object* x_9; +x_7 = lean_unbox_usize(x_4); +lean_dec(x_4); +x_8 = lean_unbox_usize(x_5); +lean_dec(x_5); +x_9 = l_Array_foldlMUnsafe_fold___at_Lake_resolveDefaultPackageTarget___spec__1(x_1, x_2, x_3, x_7, x_8, x_6); +lean_dec(x_3); +lean_dec(x_1); +return x_9; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveDefaultPackageTarget___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_resolveDefaultPackageTarget(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_resolvePackageTarget___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("package", 7); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_resolvePackageTarget(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +uint8_t x_4; +x_4 = l_Lean_Name_isAnonymous(x_3); +if (x_4 == 0) +{ +lean_object* x_5; +x_5 = l_Lake_Workspace_findPackageFacetConfig_x3f(x_3, x_1); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +lean_dec(x_2); +x_6 = l_Lake_resolvePackageTarget___closed__1; +x_7 = lean_alloc_ctor(11, 2, 0); +lean_ctor_set(x_7, 0, x_6); +lean_ctor_set(x_7, 1, x_3); +x_8 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; +} +else +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_5); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; +x_10 = lean_ctor_get(x_5, 0); +x_11 = lean_ctor_get(x_10, 1); +lean_inc(x_11); +lean_dec(x_10); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; +lean_dec(x_2); +x_12 = l_Lake_resolvePackageTarget___closed__1; +x_13 = lean_alloc_ctor(16, 2, 0); +lean_ctor_set(x_13, 0, x_12); +lean_ctor_set(x_13, 1, x_3); +lean_ctor_set_tag(x_5, 0); +lean_ctor_set(x_5, 0, x_13); +return x_5; +} +else +{ +uint8_t x_14; +lean_free_object(x_5); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +x_15 = lean_ctor_get(x_11, 0); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_2); +lean_ctor_set(x_16, 1, x_3); +x_17 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +x_18 = lean_unsigned_to_nat(1u); +x_19 = lean_mk_array(x_18, x_17); +lean_ctor_set(x_11, 0, x_19); +return x_11; +} +else +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_20 = lean_ctor_get(x_11, 0); +lean_inc(x_20); +lean_dec(x_11); +x_21 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_21, 0, x_2); +lean_ctor_set(x_21, 1, x_3); +x_22 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_20); +x_23 = lean_unsigned_to_nat(1u); +x_24 = lean_mk_array(x_23, x_22); +x_25 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_25, 0, x_24); +return x_25; +} +} +} +else +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_5, 0); +lean_inc(x_26); +lean_dec(x_5); +x_27 = lean_ctor_get(x_26, 1); +lean_inc(x_27); +lean_dec(x_26); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; lean_object* x_29; lean_object* x_30; +lean_dec(x_2); +x_28 = l_Lake_resolvePackageTarget___closed__1; +x_29 = lean_alloc_ctor(16, 2, 0); +lean_ctor_set(x_29, 0, x_28); +lean_ctor_set(x_29, 1, x_3); +x_30 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_30, 0, x_29); +return x_30; +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_31 = lean_ctor_get(x_27, 0); +lean_inc(x_31); +if (lean_is_exclusive(x_27)) { + lean_ctor_release(x_27, 0); + x_32 = x_27; +} else { + lean_dec_ref(x_27); + x_32 = lean_box(0); +} +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_2); +lean_ctor_set(x_33, 1, x_3); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_31); +x_35 = lean_unsigned_to_nat(1u); +x_36 = lean_mk_array(x_35, x_34); +if (lean_is_scalar(x_32)) { + x_37 = lean_alloc_ctor(1, 1, 0); +} else { + x_37 = x_32; +} +lean_ctor_set(x_37, 0, x_36); +return x_37; +} +} +} +} +else +{ +lean_object* x_38; +lean_dec(x_3); +x_38 = l_Lake_resolveDefaultPackageTarget(x_1, x_2); +return x_38; +} +} +} +LEAN_EXPORT lean_object* l_Lake_resolvePackageTarget___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_resolvePackageTarget(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveTargetInWorkspace(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_Workspace_findTargetConfig_x3f(x_2, x_1); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; +x_5 = l_Lake_Workspace_findLeanExe_x3f(x_2, x_1); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; +lean_inc(x_2); +x_6 = l_Lake_Workspace_findExternLib_x3f(x_2, x_1); +if (lean_obj_tag(x_6) == 0) +{ +lean_object* x_7; +x_7 = l_Lake_Workspace_findLeanLib_x3f(x_2, x_1); +if (lean_obj_tag(x_7) == 0) +{ +lean_object* x_8; lean_object* x_9; +x_8 = lean_ctor_get(x_1, 3); +x_9 = l_Lake_RBNode_dFind___at_Lake_Workspace_findPackage_x3f___spec__1(x_8, x_2); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; +lean_inc(x_2); +x_10 = l_Lake_Workspace_findTargetModule_x3f(x_2, x_1); +if (lean_obj_tag(x_10) == 0) +{ +lean_object* x_11; lean_object* x_12; +lean_dec(x_3); +x_11 = lean_alloc_ctor(12, 1, 0); +lean_ctor_set(x_11, 0, x_2); +x_12 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_12, 0, x_11); +return x_12; +} +else +{ +lean_object* x_13; lean_object* x_14; +lean_dec(x_2); +x_13 = lean_ctor_get(x_10, 0); +lean_inc(x_13); +lean_dec(x_10); +x_14 = l_Lake_resolveModuleTarget(x_1, x_13, x_3); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +return x_14; +} +else +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_14, 0); +lean_inc(x_16); +lean_dec(x_14); +x_17 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_17, 0, x_16); +return x_17; +} +} +else +{ +uint8_t x_18; +x_18 = !lean_is_exclusive(x_14); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_19 = lean_ctor_get(x_14, 0); +x_20 = lean_unsigned_to_nat(1u); +x_21 = lean_mk_array(x_20, x_19); +lean_ctor_set(x_14, 0, x_21); +return x_14; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_14, 0); +lean_inc(x_22); +lean_dec(x_14); +x_23 = lean_unsigned_to_nat(1u); +x_24 = lean_mk_array(x_23, x_22); +x_25 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_25, 0, x_24); +return x_25; +} +} +} +} +else +{ +lean_object* x_26; lean_object* x_27; +lean_dec(x_2); +x_26 = lean_ctor_get(x_9, 0); +lean_inc(x_26); +lean_dec(x_9); +x_27 = l_Lake_resolvePackageTarget(x_1, x_26, x_3); +return x_27; +} +} +else +{ +lean_object* x_28; lean_object* x_29; +lean_dec(x_2); +x_28 = lean_ctor_get(x_7, 0); +lean_inc(x_28); +lean_dec(x_7); +x_29 = l_Lake_resolveLibTarget(x_1, x_28, x_3); +return x_29; +} +} +else +{ +lean_object* x_30; lean_object* x_31; +lean_dec(x_2); +x_30 = lean_ctor_get(x_6, 0); +lean_inc(x_30); +lean_dec(x_6); +x_31 = l_Lake_resolveExternLibTarget(x_30, x_3); +if (lean_obj_tag(x_31) == 0) +{ +uint8_t x_32; +x_32 = !lean_is_exclusive(x_31); +if (x_32 == 0) +{ +return x_31; +} +else +{ +lean_object* x_33; lean_object* x_34; +x_33 = lean_ctor_get(x_31, 0); +lean_inc(x_33); +lean_dec(x_31); +x_34 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_34, 0, x_33); +return x_34; +} +} +else +{ +uint8_t x_35; +x_35 = !lean_is_exclusive(x_31); +if (x_35 == 0) +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_31, 0); +x_37 = lean_unsigned_to_nat(1u); +x_38 = lean_mk_array(x_37, x_36); +lean_ctor_set(x_31, 0, x_38); +return x_31; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_39 = lean_ctor_get(x_31, 0); +lean_inc(x_39); +lean_dec(x_31); +x_40 = lean_unsigned_to_nat(1u); +x_41 = lean_mk_array(x_40, x_39); +x_42 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_42, 0, x_41); +return x_42; +} +} +} +} +else +{ +lean_object* x_43; lean_object* x_44; +lean_dec(x_2); +x_43 = lean_ctor_get(x_5, 0); +lean_inc(x_43); +lean_dec(x_5); +x_44 = l_Lake_resolveExeTarget(x_43, x_3); +if (lean_obj_tag(x_44) == 0) +{ +uint8_t x_45; +x_45 = !lean_is_exclusive(x_44); +if (x_45 == 0) +{ +return x_44; +} +else +{ +lean_object* x_46; lean_object* x_47; +x_46 = lean_ctor_get(x_44, 0); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_47, 0, x_46); +return x_47; +} +} +else +{ +uint8_t x_48; +x_48 = !lean_is_exclusive(x_44); +if (x_48 == 0) +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_44, 0); +x_50 = lean_unsigned_to_nat(1u); +x_51 = lean_mk_array(x_50, x_49); +lean_ctor_set(x_44, 0, x_51); +return x_44; +} +else +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_44, 0); +lean_inc(x_52); +lean_dec(x_44); +x_53 = lean_unsigned_to_nat(1u); +x_54 = lean_mk_array(x_53, x_52); +x_55 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_55, 0, x_54); +return x_55; +} +} +} +} +else +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_4, 0); +lean_inc(x_56); +lean_dec(x_4); +x_57 = lean_ctor_get(x_56, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_56, 1); +lean_inc(x_58); +lean_dec(x_56); +x_59 = l_Lake_resolveCustomTarget(x_57, x_2, x_3, x_58); +if (lean_obj_tag(x_59) == 0) +{ +uint8_t x_60; +x_60 = !lean_is_exclusive(x_59); +if (x_60 == 0) +{ +return x_59; +} +else +{ +lean_object* x_61; lean_object* x_62; +x_61 = lean_ctor_get(x_59, 0); +lean_inc(x_61); +lean_dec(x_59); +x_62 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_62, 0, x_61); +return x_62; +} +} +else +{ +uint8_t x_63; +x_63 = !lean_is_exclusive(x_59); +if (x_63 == 0) +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_59, 0); +x_65 = lean_unsigned_to_nat(1u); +x_66 = lean_mk_array(x_65, x_64); +lean_ctor_set(x_59, 0, x_66); +return x_59; +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_67 = lean_ctor_get(x_59, 0); +lean_inc(x_67); +lean_dec(x_59); +x_68 = lean_unsigned_to_nat(1u); +x_69 = lean_mk_array(x_68, x_67); +x_70 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_70, 0, x_69); +return x_70; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_resolveTargetInWorkspace___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; +x_4 = l_Lake_resolveTargetInWorkspace(x_1, x_2, x_3); +lean_dec(x_1); +return x_4; +} +} +static lean_object* _init_l_Lake_resolveTargetBaseSpec___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("/", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveTargetBaseSpec___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("@", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveTargetBaseSpec___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("+", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_resolveTargetBaseSpec___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 47; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_resolveTargetBaseSpec(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +lean_object* x_4; lean_object* x_5; +x_4 = l_Lake_resolveTargetBaseSpec___closed__1; +lean_inc(x_2); +x_5 = l_String_splitOn(x_2, x_4); +if (lean_obj_tag(x_5) == 0) +{ +lean_object* x_6; lean_object* x_7; lean_object* x_8; +lean_dec(x_3); +lean_dec(x_1); +x_6 = l_Lake_resolveTargetBaseSpec___boxed__const__1; +x_7 = lean_alloc_ctor(17, 2, 0); +lean_ctor_set(x_7, 0, x_2); +lean_ctor_set(x_7, 1, x_6); +x_8 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_8, 0, x_7); +return x_8; +} +else +{ +lean_object* x_9; +x_9 = lean_ctor_get(x_5, 1); +lean_inc(x_9); +if (lean_obj_tag(x_9) == 0) +{ +lean_object* x_10; uint8_t x_11; +lean_dec(x_2); +x_10 = lean_ctor_get(x_5, 0); +lean_inc(x_10); +lean_dec(x_5); +x_11 = l_String_isEmpty(x_10); +if (x_11 == 0) +{ +lean_object* x_12; uint8_t x_13; +x_12 = l_Lake_resolveTargetBaseSpec___closed__2; +lean_inc(x_10); +x_13 = l_String_startsWith(x_10, x_12); +if (x_13 == 0) +{ +lean_object* x_14; uint8_t x_15; +x_14 = l_Lake_resolveTargetBaseSpec___closed__3; +lean_inc(x_10); +x_15 = l_String_startsWith(x_10, x_14); +if (x_15 == 0) +{ +lean_object* x_16; lean_object* x_17; +x_16 = l_Lake_stringToLegalOrSimpleName(x_10); +x_17 = l_Lake_resolveTargetInWorkspace(x_1, x_16, x_3); +lean_dec(x_1); +return x_17; +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_unsigned_to_nat(1u); +x_19 = l_String_drop(x_10, x_18); +x_20 = l_String_toName(x_19); +lean_inc(x_20); +x_21 = l_Lake_Workspace_findTargetModule_x3f(x_20, x_1); +if (lean_obj_tag(x_21) == 0) +{ +lean_object* x_22; lean_object* x_23; +lean_dec(x_3); +lean_dec(x_1); +x_22 = lean_alloc_ctor(9, 1, 0); +lean_ctor_set(x_22, 0, x_20); +x_23 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_23, 0, x_22); +return x_23; +} +else +{ +lean_object* x_24; lean_object* x_25; +lean_dec(x_20); +x_24 = lean_ctor_get(x_21, 0); +lean_inc(x_24); +lean_dec(x_21); +x_25 = l_Lake_resolveModuleTarget(x_1, x_24, x_3); +lean_dec(x_1); +if (lean_obj_tag(x_25) == 0) +{ +uint8_t x_26; +x_26 = !lean_is_exclusive(x_25); +if (x_26 == 0) +{ +return x_25; +} +else +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_ctor_get(x_25, 0); +lean_inc(x_27); +lean_dec(x_25); +x_28 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_28, 0, x_27); +return x_28; +} +} +else +{ +uint8_t x_29; +x_29 = !lean_is_exclusive(x_25); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; +x_30 = lean_ctor_get(x_25, 0); +x_31 = lean_mk_array(x_18, x_30); +lean_ctor_set(x_25, 0, x_31); +return x_25; +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_25, 0); +lean_inc(x_32); +lean_dec(x_25); +x_33 = lean_mk_array(x_18, x_32); +x_34 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_34, 0, x_33); +return x_34; +} +} +} +} +} +else +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; +x_35 = lean_unsigned_to_nat(1u); +x_36 = l_String_drop(x_10, x_35); +x_37 = l_Lake_parsePackageSpec(x_1, x_36); +if (lean_obj_tag(x_37) == 0) +{ +uint8_t x_38; +lean_dec(x_3); +lean_dec(x_1); +x_38 = !lean_is_exclusive(x_37); +if (x_38 == 0) +{ +return x_37; +} +else +{ +lean_object* x_39; lean_object* x_40; +x_39 = lean_ctor_get(x_37, 0); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_40, 0, x_39); +return x_40; +} +} +else +{ +lean_object* x_41; lean_object* x_42; +x_41 = lean_ctor_get(x_37, 0); +lean_inc(x_41); +lean_dec(x_37); +x_42 = l_Lake_resolvePackageTarget(x_1, x_41, x_3); +lean_dec(x_1); +return x_42; +} +} +} +else +{ +lean_object* x_43; lean_object* x_44; +lean_dec(x_10); +x_43 = lean_ctor_get(x_1, 0); +lean_inc(x_43); +x_44 = l_Lake_resolvePackageTarget(x_1, x_43, x_3); +lean_dec(x_1); +return x_44; +} +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_45 = lean_ctor_get(x_5, 0); +lean_inc(x_45); +lean_dec(x_5); +x_46 = lean_ctor_get(x_9, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_9, 1); +lean_inc(x_47); +lean_dec(x_9); +if (lean_obj_tag(x_47) == 0) +{ +lean_object* x_100; uint8_t x_101; +lean_dec(x_2); +x_100 = l_Lake_resolveTargetBaseSpec___closed__2; +lean_inc(x_45); +x_101 = l_String_startsWith(x_45, x_100); +if (x_101 == 0) +{ +x_48 = x_45; +goto block_99; +} +else +{ +lean_object* x_102; lean_object* x_103; +x_102 = lean_unsigned_to_nat(1u); +x_103 = l_String_drop(x_45, x_102); +x_48 = x_103; +goto block_99; +} +} +else +{ +uint8_t x_104; +lean_dec(x_46); +lean_dec(x_45); +lean_dec(x_3); +lean_dec(x_1); +x_104 = !lean_is_exclusive(x_47); +if (x_104 == 0) +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; +x_105 = lean_ctor_get(x_47, 1); +lean_dec(x_105); +x_106 = lean_ctor_get(x_47, 0); +lean_dec(x_106); +x_107 = l_Lake_resolveTargetBaseSpec___boxed__const__1; +lean_ctor_set_tag(x_47, 17); +lean_ctor_set(x_47, 1, x_107); +lean_ctor_set(x_47, 0, x_2); +x_108 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_108, 0, x_47); +return x_108; +} +else +{ +lean_object* x_109; lean_object* x_110; lean_object* x_111; +lean_dec(x_47); +x_109 = l_Lake_resolveTargetBaseSpec___boxed__const__1; +x_110 = lean_alloc_ctor(17, 2, 0); +lean_ctor_set(x_110, 0, x_2); +lean_ctor_set(x_110, 1, x_109); +x_111 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_111, 0, x_110); +return x_111; +} +} +block_99: +{ +lean_object* x_49; +x_49 = l_Lake_parsePackageSpec(x_1, x_48); +if (lean_obj_tag(x_49) == 0) +{ +uint8_t x_50; +lean_dec(x_46); +lean_dec(x_3); +lean_dec(x_1); +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) +{ +return x_49; +} +else +{ +lean_object* x_51; lean_object* x_52; +x_51 = lean_ctor_get(x_49, 0); +lean_inc(x_51); +lean_dec(x_49); +x_52 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_52, 0, x_51); +return x_52; +} +} +else +{ +uint8_t x_53; +x_53 = !lean_is_exclusive(x_49); +if (x_53 == 0) +{ +lean_object* x_54; uint8_t x_55; +x_54 = lean_ctor_get(x_49, 0); +x_55 = l_String_isEmpty(x_46); +if (x_55 == 0) +{ +lean_object* x_56; uint8_t x_57; +x_56 = l_Lake_resolveTargetBaseSpec___closed__3; +lean_inc(x_46); +x_57 = l_String_startsWith(x_46, x_56); +if (x_57 == 0) +{ +lean_object* x_58; lean_object* x_59; +lean_free_object(x_49); +x_58 = l_Lake_stringToLegalOrSimpleName(x_46); +x_59 = l_Lake_resolveTargetInPackage(x_1, x_54, x_58, x_3); +lean_dec(x_1); +return x_59; +} +else +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_60 = lean_unsigned_to_nat(1u); +x_61 = l_String_drop(x_46, x_60); +x_62 = l_String_toName(x_61); +lean_inc(x_62); +x_63 = l_Lake_Package_findTargetModule_x3f(x_62, x_54); +if (lean_obj_tag(x_63) == 0) +{ +lean_object* x_64; +lean_dec(x_3); +lean_dec(x_1); +x_64 = lean_alloc_ctor(9, 1, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set_tag(x_49, 0); +lean_ctor_set(x_49, 0, x_64); +return x_49; +} +else +{ +lean_object* x_65; lean_object* x_66; +lean_dec(x_62); +lean_free_object(x_49); +x_65 = lean_ctor_get(x_63, 0); +lean_inc(x_65); +lean_dec(x_63); +x_66 = l_Lake_resolveModuleTarget(x_1, x_65, x_3); +lean_dec(x_1); +if (lean_obj_tag(x_66) == 0) +{ +uint8_t x_67; +x_67 = !lean_is_exclusive(x_66); +if (x_67 == 0) +{ +return x_66; +} +else +{ +lean_object* x_68; lean_object* x_69; +x_68 = lean_ctor_get(x_66, 0); +lean_inc(x_68); +lean_dec(x_66); +x_69 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_69, 0, x_68); +return x_69; +} +} +else +{ +uint8_t x_70; +x_70 = !lean_is_exclusive(x_66); +if (x_70 == 0) +{ +lean_object* x_71; lean_object* x_72; +x_71 = lean_ctor_get(x_66, 0); +x_72 = lean_mk_array(x_60, x_71); +lean_ctor_set(x_66, 0, x_72); +return x_66; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_73 = lean_ctor_get(x_66, 0); +lean_inc(x_73); +lean_dec(x_66); +x_74 = lean_mk_array(x_60, x_73); +x_75 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_75, 0, x_74); +return x_75; +} +} +} +} +} +else +{ +lean_object* x_76; +lean_free_object(x_49); +lean_dec(x_46); +x_76 = l_Lake_resolvePackageTarget(x_1, x_54, x_3); +lean_dec(x_1); +return x_76; +} +} +else +{ +lean_object* x_77; uint8_t x_78; +x_77 = lean_ctor_get(x_49, 0); +lean_inc(x_77); +lean_dec(x_49); +x_78 = l_String_isEmpty(x_46); +if (x_78 == 0) +{ +lean_object* x_79; uint8_t x_80; +x_79 = l_Lake_resolveTargetBaseSpec___closed__3; +lean_inc(x_46); +x_80 = l_String_startsWith(x_46, x_79); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = l_Lake_stringToLegalOrSimpleName(x_46); +x_82 = l_Lake_resolveTargetInPackage(x_1, x_77, x_81, x_3); +lean_dec(x_1); +return x_82; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_83 = lean_unsigned_to_nat(1u); +x_84 = l_String_drop(x_46, x_83); +x_85 = l_String_toName(x_84); +lean_inc(x_85); +x_86 = l_Lake_Package_findTargetModule_x3f(x_85, x_77); +if (lean_obj_tag(x_86) == 0) +{ +lean_object* x_87; lean_object* x_88; +lean_dec(x_3); +lean_dec(x_1); +x_87 = lean_alloc_ctor(9, 1, 0); +lean_ctor_set(x_87, 0, x_85); +x_88 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_88, 0, x_87); +return x_88; +} +else +{ +lean_object* x_89; lean_object* x_90; +lean_dec(x_85); +x_89 = lean_ctor_get(x_86, 0); +lean_inc(x_89); +lean_dec(x_86); +x_90 = l_Lake_resolveModuleTarget(x_1, x_89, x_3); +lean_dec(x_1); +if (lean_obj_tag(x_90) == 0) +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_91 = lean_ctor_get(x_90, 0); +lean_inc(x_91); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + x_92 = x_90; +} else { + lean_dec_ref(x_90); + x_92 = lean_box(0); +} +if (lean_is_scalar(x_92)) { + x_93 = lean_alloc_ctor(0, 1, 0); +} else { + x_93 = x_92; +} +lean_ctor_set(x_93, 0, x_91); +return x_93; +} +else +{ +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_94 = lean_ctor_get(x_90, 0); +lean_inc(x_94); +if (lean_is_exclusive(x_90)) { + lean_ctor_release(x_90, 0); + x_95 = x_90; +} else { + lean_dec_ref(x_90); + x_95 = lean_box(0); +} +x_96 = lean_mk_array(x_83, x_94); +if (lean_is_scalar(x_95)) { + x_97 = lean_alloc_ctor(1, 1, 0); +} else { + x_97 = x_95; +} +lean_ctor_set(x_97, 0, x_96); +return x_97; +} +} +} +} +else +{ +lean_object* x_98; +lean_dec(x_46); +x_98 = l_Lake_resolvePackageTarget(x_1, x_77, x_3); +lean_dec(x_1); +return x_98; +} +} +} +} +} +} +} +} +static lean_object* _init_l_Lake_parseExeTargetSpec___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 47; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_parseExeTargetSpec(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = l_Lake_resolveTargetBaseSpec___closed__1; +lean_inc(x_2); +x_4 = l_String_splitOn(x_2, x_3); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = l_Lake_parseExeTargetSpec___boxed__const__1; +x_6 = lean_alloc_ctor(17, 2, 0); +lean_ctor_set(x_6, 0, x_2); +lean_ctor_set(x_6, 1, x_5); +x_7 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_7, 0, x_6); +return x_7; +} +else +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_4, 1); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +x_9 = lean_ctor_get(x_4, 0); +lean_inc(x_9); +lean_dec(x_4); +x_10 = l_Lake_stringToLegalOrSimpleName(x_9); +x_11 = l_Lake_Workspace_findLeanExe_x3f(x_10, x_1); +lean_dec(x_10); +if (lean_obj_tag(x_11) == 0) +{ +lean_object* x_12; lean_object* x_13; +x_12 = lean_alloc_ctor(19, 1, 0); +lean_ctor_set(x_12, 0, x_2); +x_13 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_13, 0, x_12); +return x_13; +} +else +{ +uint8_t x_14; +lean_dec(x_2); +x_14 = !lean_is_exclusive(x_11); +if (x_14 == 0) +{ +return x_11; +} +else +{ +lean_object* x_15; lean_object* x_16; +x_15 = lean_ctor_get(x_11, 0); +lean_inc(x_15); +lean_dec(x_11); +x_16 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_16, 0, x_15); +return x_16; +} +} +} +else +{ +lean_object* x_17; +x_17 = lean_ctor_get(x_8, 1); +lean_inc(x_17); +if (lean_obj_tag(x_17) == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_ctor_get(x_4, 0); +lean_inc(x_18); +lean_dec(x_4); +x_19 = !lean_is_exclusive(x_8); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; +x_20 = lean_ctor_get(x_8, 0); +x_21 = lean_ctor_get(x_8, 1); +lean_dec(x_21); +x_22 = l_Lake_resolveTargetBaseSpec___closed__2; +lean_inc(x_18); +x_23 = l_String_startsWith(x_18, x_22); +if (x_23 == 0) +{ +lean_object* x_24; +x_24 = l_Lake_parsePackageSpec(x_1, x_18); +if (lean_obj_tag(x_24) == 0) +{ +uint8_t x_25; +lean_free_object(x_8); +lean_dec(x_20); +lean_dec(x_2); +x_25 = !lean_is_exclusive(x_24); +if (x_25 == 0) +{ +return x_24; +} +else +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_24, 0); +lean_inc(x_26); +lean_dec(x_24); +x_27 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_27, 0, x_26); +return x_27; +} +} +else +{ +uint8_t x_28; +x_28 = !lean_is_exclusive(x_24); +if (x_28 == 0) +{ +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_29 = lean_ctor_get(x_24, 0); +x_30 = l_Lake_stringToLegalOrSimpleName(x_20); +x_31 = lean_ctor_get(x_29, 9); +lean_inc(x_31); +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +lean_dec(x_31); +x_33 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_32, x_30); +lean_dec(x_30); +lean_dec(x_32); +if (lean_obj_tag(x_33) == 0) +{ +lean_object* x_34; +lean_dec(x_29); +lean_free_object(x_8); +x_34 = lean_alloc_ctor(19, 1, 0); +lean_ctor_set(x_34, 0, x_2); +lean_ctor_set_tag(x_24, 0); +lean_ctor_set(x_24, 0, x_34); +return x_24; +} +else +{ +lean_object* x_35; +lean_dec(x_2); +x_35 = lean_ctor_get(x_33, 0); +lean_inc(x_35); +lean_dec(x_33); +lean_ctor_set_tag(x_8, 0); +lean_ctor_set(x_8, 1, x_35); +lean_ctor_set(x_8, 0, x_29); +lean_ctor_set(x_24, 0, x_8); +return x_24; +} +} +else +{ +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_36 = lean_ctor_get(x_24, 0); +lean_inc(x_36); +lean_dec(x_24); +x_37 = l_Lake_stringToLegalOrSimpleName(x_20); +x_38 = lean_ctor_get(x_36, 9); +lean_inc(x_38); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_39, x_37); +lean_dec(x_37); +lean_dec(x_39); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; +lean_dec(x_36); +lean_free_object(x_8); +x_41 = lean_alloc_ctor(19, 1, 0); +lean_ctor_set(x_41, 0, x_2); +x_42 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_42, 0, x_41); +return x_42; +} +else +{ +lean_object* x_43; lean_object* x_44; +lean_dec(x_2); +x_43 = lean_ctor_get(x_40, 0); +lean_inc(x_43); +lean_dec(x_40); +lean_ctor_set_tag(x_8, 0); +lean_ctor_set(x_8, 1, x_43); +lean_ctor_set(x_8, 0, x_36); +x_44 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_44, 0, x_8); +return x_44; +} +} +} +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_unsigned_to_nat(1u); +x_46 = l_String_drop(x_18, x_45); +x_47 = l_Lake_parsePackageSpec(x_1, x_46); +if (lean_obj_tag(x_47) == 0) +{ +uint8_t x_48; +lean_free_object(x_8); +lean_dec(x_20); +lean_dec(x_2); +x_48 = !lean_is_exclusive(x_47); +if (x_48 == 0) +{ +return x_47; +} +else +{ +lean_object* x_49; lean_object* x_50; +x_49 = lean_ctor_get(x_47, 0); +lean_inc(x_49); +lean_dec(x_47); +x_50 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_50, 0, x_49); +return x_50; +} +} +else +{ +uint8_t x_51; +x_51 = !lean_is_exclusive(x_47); +if (x_51 == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_52 = lean_ctor_get(x_47, 0); +x_53 = l_Lake_stringToLegalOrSimpleName(x_20); +x_54 = lean_ctor_get(x_52, 9); +lean_inc(x_54); +x_55 = lean_ctor_get(x_54, 0); +lean_inc(x_55); +lean_dec(x_54); +x_56 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_55, x_53); +lean_dec(x_53); +lean_dec(x_55); +if (lean_obj_tag(x_56) == 0) +{ +lean_object* x_57; +lean_dec(x_52); +lean_free_object(x_8); +x_57 = lean_alloc_ctor(19, 1, 0); +lean_ctor_set(x_57, 0, x_2); +lean_ctor_set_tag(x_47, 0); +lean_ctor_set(x_47, 0, x_57); +return x_47; +} +else +{ +lean_object* x_58; +lean_dec(x_2); +x_58 = lean_ctor_get(x_56, 0); +lean_inc(x_58); +lean_dec(x_56); +lean_ctor_set_tag(x_8, 0); +lean_ctor_set(x_8, 1, x_58); +lean_ctor_set(x_8, 0, x_52); +lean_ctor_set(x_47, 0, x_8); +return x_47; +} +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_59 = lean_ctor_get(x_47, 0); +lean_inc(x_59); +lean_dec(x_47); +x_60 = l_Lake_stringToLegalOrSimpleName(x_20); +x_61 = lean_ctor_get(x_59, 9); +lean_inc(x_61); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +lean_dec(x_61); +x_63 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_62, x_60); +lean_dec(x_60); +lean_dec(x_62); +if (lean_obj_tag(x_63) == 0) +{ +lean_object* x_64; lean_object* x_65; +lean_dec(x_59); +lean_free_object(x_8); +x_64 = lean_alloc_ctor(19, 1, 0); +lean_ctor_set(x_64, 0, x_2); +x_65 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_65, 0, x_64); +return x_65; +} +else +{ +lean_object* x_66; lean_object* x_67; +lean_dec(x_2); +x_66 = lean_ctor_get(x_63, 0); +lean_inc(x_66); +lean_dec(x_63); +lean_ctor_set_tag(x_8, 0); +lean_ctor_set(x_8, 1, x_66); +lean_ctor_set(x_8, 0, x_59); +x_67 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_67, 0, x_8); +return x_67; +} +} +} +} +} +else +{ +lean_object* x_68; lean_object* x_69; uint8_t x_70; +x_68 = lean_ctor_get(x_8, 0); +lean_inc(x_68); +lean_dec(x_8); +x_69 = l_Lake_resolveTargetBaseSpec___closed__2; +lean_inc(x_18); +x_70 = l_String_startsWith(x_18, x_69); +if (x_70 == 0) +{ +lean_object* x_71; +x_71 = l_Lake_parsePackageSpec(x_1, x_18); +if (lean_obj_tag(x_71) == 0) +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; +lean_dec(x_68); +lean_dec(x_2); +x_72 = lean_ctor_get(x_71, 0); +lean_inc(x_72); +if (lean_is_exclusive(x_71)) { + lean_ctor_release(x_71, 0); + x_73 = x_71; +} else { + lean_dec_ref(x_71); + x_73 = lean_box(0); +} +if (lean_is_scalar(x_73)) { + x_74 = lean_alloc_ctor(0, 1, 0); +} else { + x_74 = x_73; +} +lean_ctor_set(x_74, 0, x_72); +return x_74; +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_75 = lean_ctor_get(x_71, 0); +lean_inc(x_75); +if (lean_is_exclusive(x_71)) { + lean_ctor_release(x_71, 0); + x_76 = x_71; +} else { + lean_dec_ref(x_71); + x_76 = lean_box(0); +} +x_77 = l_Lake_stringToLegalOrSimpleName(x_68); +x_78 = lean_ctor_get(x_75, 9); +lean_inc(x_78); +x_79 = lean_ctor_get(x_78, 0); +lean_inc(x_79); +lean_dec(x_78); +x_80 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_79, x_77); +lean_dec(x_77); +lean_dec(x_79); +if (lean_obj_tag(x_80) == 0) +{ +lean_object* x_81; lean_object* x_82; +lean_dec(x_75); +x_81 = lean_alloc_ctor(19, 1, 0); +lean_ctor_set(x_81, 0, x_2); +if (lean_is_scalar(x_76)) { + x_82 = lean_alloc_ctor(0, 1, 0); +} else { + x_82 = x_76; + lean_ctor_set_tag(x_82, 0); +} +lean_ctor_set(x_82, 0, x_81); +return x_82; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; +lean_dec(x_2); +x_83 = lean_ctor_get(x_80, 0); +lean_inc(x_83); +lean_dec(x_80); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_75); +lean_ctor_set(x_84, 1, x_83); +if (lean_is_scalar(x_76)) { + x_85 = lean_alloc_ctor(1, 1, 0); +} else { + x_85 = x_76; +} +lean_ctor_set(x_85, 0, x_84); +return x_85; +} +} +} +else +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_86 = lean_unsigned_to_nat(1u); +x_87 = l_String_drop(x_18, x_86); +x_88 = l_Lake_parsePackageSpec(x_1, x_87); +if (lean_obj_tag(x_88) == 0) +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; +lean_dec(x_68); +lean_dec(x_2); +x_89 = lean_ctor_get(x_88, 0); +lean_inc(x_89); +if (lean_is_exclusive(x_88)) { + lean_ctor_release(x_88, 0); + x_90 = x_88; +} else { + lean_dec_ref(x_88); + x_90 = lean_box(0); +} +if (lean_is_scalar(x_90)) { + x_91 = lean_alloc_ctor(0, 1, 0); +} else { + x_91 = x_90; +} +lean_ctor_set(x_91, 0, x_89); +return x_91; +} +else +{ +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_92 = lean_ctor_get(x_88, 0); +lean_inc(x_92); +if (lean_is_exclusive(x_88)) { + lean_ctor_release(x_88, 0); + x_93 = x_88; +} else { + lean_dec_ref(x_88); + x_93 = lean_box(0); +} +x_94 = l_Lake_stringToLegalOrSimpleName(x_68); +x_95 = lean_ctor_get(x_92, 9); +lean_inc(x_95); +x_96 = lean_ctor_get(x_95, 0); +lean_inc(x_96); +lean_dec(x_95); +x_97 = l_Lean_RBNode_find___at_Lake_Package_findLeanExe_x3f___spec__1(x_96, x_94); +lean_dec(x_94); +lean_dec(x_96); +if (lean_obj_tag(x_97) == 0) +{ +lean_object* x_98; lean_object* x_99; +lean_dec(x_92); +x_98 = lean_alloc_ctor(19, 1, 0); +lean_ctor_set(x_98, 0, x_2); +if (lean_is_scalar(x_93)) { + x_99 = lean_alloc_ctor(0, 1, 0); +} else { + x_99 = x_93; + lean_ctor_set_tag(x_99, 0); +} +lean_ctor_set(x_99, 0, x_98); +return x_99; +} +else +{ +lean_object* x_100; lean_object* x_101; lean_object* x_102; +lean_dec(x_2); +x_100 = lean_ctor_get(x_97, 0); +lean_inc(x_100); +lean_dec(x_97); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_92); +lean_ctor_set(x_101, 1, x_100); +if (lean_is_scalar(x_93)) { + x_102 = lean_alloc_ctor(1, 1, 0); +} else { + x_102 = x_93; +} +lean_ctor_set(x_102, 0, x_101); +return x_102; +} +} +} +} +} +else +{ +uint8_t x_103; +lean_dec(x_8); +lean_dec(x_4); +x_103 = !lean_is_exclusive(x_17); +if (x_103 == 0) +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_104 = lean_ctor_get(x_17, 1); +lean_dec(x_104); +x_105 = lean_ctor_get(x_17, 0); +lean_dec(x_105); +x_106 = l_Lake_parseExeTargetSpec___boxed__const__1; +lean_ctor_set_tag(x_17, 17); +lean_ctor_set(x_17, 1, x_106); +lean_ctor_set(x_17, 0, x_2); +x_107 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_107, 0, x_17); +return x_107; +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; +lean_dec(x_17); +x_108 = l_Lake_parseExeTargetSpec___boxed__const__1; +x_109 = lean_alloc_ctor(17, 2, 0); +lean_ctor_set(x_109, 0, x_2); +lean_ctor_set(x_109, 1, x_108); +x_110 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_110, 0, x_109); +return x_110; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_parseExeTargetSpec___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_parseExeTargetSpec(x_1, x_2); +lean_dec(x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_parseTargetSpec___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(":", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_parseTargetSpec___boxed__const__1() { +_start: +{ +uint32_t x_1; lean_object* x_2; +x_1 = 58; +x_2 = lean_box_uint32(x_1); +return x_2; +} +} +LEAN_EXPORT lean_object* l_Lake_parseTargetSpec(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = l_Lake_parseTargetSpec___closed__1; +lean_inc(x_2); +x_4 = l_String_splitOn(x_2, x_3); +if (lean_obj_tag(x_4) == 0) +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +lean_dec(x_1); +x_5 = l_Lake_parseTargetSpec___boxed__const__1; +x_6 = lean_alloc_ctor(17, 2, 0); +lean_ctor_set(x_6, 0, x_2); +lean_ctor_set(x_6, 1, x_5); +x_7 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_7, 0, x_6); +return x_7; +} +else +{ +lean_object* x_8; +x_8 = lean_ctor_get(x_4, 1); +lean_inc(x_8); +if (lean_obj_tag(x_8) == 0) +{ +lean_object* x_9; lean_object* x_10; lean_object* x_11; +lean_dec(x_2); +x_9 = lean_ctor_get(x_4, 0); +lean_inc(x_9); +lean_dec(x_4); +x_10 = lean_box(0); +x_11 = l_Lake_resolveTargetBaseSpec(x_1, x_9, x_10); +return x_11; +} +else +{ +lean_object* x_12; +x_12 = lean_ctor_get(x_8, 1); +lean_inc(x_12); +if (lean_obj_tag(x_12) == 0) +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +lean_dec(x_2); +x_13 = lean_ctor_get(x_4, 0); +lean_inc(x_13); +lean_dec(x_4); +x_14 = lean_ctor_get(x_8, 0); +lean_inc(x_14); +lean_dec(x_8); +x_15 = l_String_toName(x_14); +x_16 = l_Lake_resolveTargetBaseSpec(x_1, x_13, x_15); +return x_16; +} +else +{ +uint8_t x_17; +lean_dec(x_8); +lean_dec(x_4); +lean_dec(x_1); +x_17 = !lean_is_exclusive(x_12); +if (x_17 == 0) +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_18 = lean_ctor_get(x_12, 1); +lean_dec(x_18); +x_19 = lean_ctor_get(x_12, 0); +lean_dec(x_19); +x_20 = l_Lake_parseTargetSpec___boxed__const__1; +lean_ctor_set_tag(x_12, 17); +lean_ctor_set(x_12, 1, x_20); +lean_ctor_set(x_12, 0, x_2); +x_21 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_21, 0, x_12); +return x_21; +} +else +{ +lean_object* x_22; lean_object* x_23; lean_object* x_24; +lean_dec(x_12); +x_22 = l_Lake_parseTargetSpec___boxed__const__1; +x_23 = lean_alloc_ctor(17, 2, 0); +lean_ctor_set(x_23, 0, x_2); +lean_ctor_set(x_23, 1, x_22); +x_24 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_24, 0, x_23); +return x_24; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lake_parseTargetSpecs___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) { +_start: +{ +if (lean_obj_tag(x_2) == 0) +{ +lean_object* x_4; +lean_dec(x_1); +x_4 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_4, 0, x_3); +return x_4; +} +else +{ +lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_5 = lean_ctor_get(x_2, 0); +lean_inc(x_5); +x_6 = lean_ctor_get(x_2, 1); +lean_inc(x_6); +lean_dec(x_2); +lean_inc(x_1); +x_7 = l_Lake_parseTargetSpec(x_1, x_5); +if (lean_obj_tag(x_7) == 0) +{ +uint8_t x_8; +lean_dec(x_6); +lean_dec(x_3); +lean_dec(x_1); +x_8 = !lean_is_exclusive(x_7); +if (x_8 == 0) +{ +return x_7; +} +else +{ +lean_object* x_9; lean_object* x_10; +x_9 = lean_ctor_get(x_7, 0); +lean_inc(x_9); +lean_dec(x_7); +x_10 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_10, 0, x_9); +return x_10; +} +} +else +{ +lean_object* x_11; lean_object* x_12; +x_11 = lean_ctor_get(x_7, 0); +lean_inc(x_11); +lean_dec(x_7); +x_12 = l_Array_append___rarg(x_3, x_11); +lean_dec(x_11); +x_2 = x_6; +x_3 = x_12; +goto _start; +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_parseTargetSpecs___lambda__1(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_3, 0, x_1); +return x_3; +} +} +static lean_object* _init_l_Lake_parseTargetSpecs___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_parseTargetSpecs___lambda__1___boxed), 2, 0); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_parseTargetSpecs(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; lean_object* x_4; +x_3 = l_Lake_resolveDefaultPackageTarget___closed__1; +lean_inc(x_1); +x_4 = l_List_forIn_loop___at_Lake_parseTargetSpecs___spec__1(x_1, x_2, x_3); +if (lean_obj_tag(x_4) == 0) +{ +uint8_t x_5; +lean_dec(x_1); +x_5 = !lean_is_exclusive(x_4); +if (x_5 == 0) +{ +return x_4; +} +else +{ +lean_object* x_6; lean_object* x_7; +x_6 = lean_ctor_get(x_4, 0); +lean_inc(x_6); +lean_dec(x_4); +x_7 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_7, 0, x_6); +return x_7; +} +} +else +{ +lean_object* x_8; lean_object* x_9; uint8_t x_10; +x_8 = lean_ctor_get(x_4, 0); +lean_inc(x_8); +lean_dec(x_4); +x_9 = l_Lake_parseTargetSpecs___closed__1; +x_10 = l_Array_isEmpty___rarg(x_8); +if (x_10 == 0) +{ +lean_object* x_11; lean_object* x_12; +lean_dec(x_1); +x_11 = lean_box(0); +x_12 = lean_apply_2(x_9, x_8, x_11); +return x_12; +} +else +{ +lean_object* x_13; lean_object* x_14; +lean_dec(x_8); +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = l_Lake_resolveDefaultPackageTarget(x_1, x_13); +lean_dec(x_1); +if (lean_obj_tag(x_14) == 0) +{ +uint8_t x_15; +x_15 = !lean_is_exclusive(x_14); +if (x_15 == 0) +{ +return x_14; +} +else +{ +lean_object* x_16; lean_object* x_17; +x_16 = lean_ctor_get(x_14, 0); +lean_inc(x_16); +lean_dec(x_14); +x_17 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_17, 0, x_16); +return x_17; +} +} +else +{ +lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_18 = lean_ctor_get(x_14, 0); +lean_inc(x_18); +lean_dec(x_14); +x_19 = lean_box(0); +x_20 = lean_apply_2(x_9, x_18, x_19); +return x_20; +} +} +} +} +} +LEAN_EXPORT lean_object* l_Lake_parseTargetSpecs___lambda__1___boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l_Lake_parseTargetSpecs___lambda__1(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_Build_Index(uint8_t builtin, lean_object*); +lean_object* initialize_Lake_CLI_Error(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_CLI_Build(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_Build_Index(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Lake_CLI_Error(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_BuildData_toBuildJob___rarg___closed__1 = _init_l_Lake_BuildData_toBuildJob___rarg___closed__1(); +lean_mark_persistent(l_Lake_BuildData_toBuildJob___rarg___closed__1); +l_Lake_BuildData_toBuildJob___rarg___closed__2 = _init_l_Lake_BuildData_toBuildJob___rarg___closed__2(); +lean_mark_persistent(l_Lake_BuildData_toBuildJob___rarg___closed__2); +l_Lake_mkBuildSpec___rarg___closed__1 = _init_l_Lake_mkBuildSpec___rarg___closed__1(); +lean_mark_persistent(l_Lake_mkBuildSpec___rarg___closed__1); +l_Lake_resolveModuleTarget___closed__1 = _init_l_Lake_resolveModuleTarget___closed__1(); +lean_mark_persistent(l_Lake_resolveModuleTarget___closed__1); +l_Lake_resolveModuleTarget___closed__2 = _init_l_Lake_resolveModuleTarget___closed__2(); +lean_mark_persistent(l_Lake_resolveModuleTarget___closed__2); +l_Lake_resolveModuleTarget___closed__3 = _init_l_Lake_resolveModuleTarget___closed__3(); +lean_mark_persistent(l_Lake_resolveModuleTarget___closed__3); +l_Lake_resolveLibTarget_resolveFacet___closed__1 = _init_l_Lake_resolveLibTarget_resolveFacet___closed__1(); +lean_mark_persistent(l_Lake_resolveLibTarget_resolveFacet___closed__1); +l_Lake_resolveExeTarget___closed__1 = _init_l_Lake_resolveExeTarget___closed__1(); +lean_mark_persistent(l_Lake_resolveExeTarget___closed__1); +l_Lake_resolveExeTarget___closed__2 = _init_l_Lake_resolveExeTarget___closed__2(); +lean_mark_persistent(l_Lake_resolveExeTarget___closed__2); +l_Lake_resolveExeTarget___closed__3 = _init_l_Lake_resolveExeTarget___closed__3(); +lean_mark_persistent(l_Lake_resolveExeTarget___closed__3); +l_Lake_resolveExternLibTarget___closed__1 = _init_l_Lake_resolveExternLibTarget___closed__1(); +lean_mark_persistent(l_Lake_resolveExternLibTarget___closed__1); +l_Lake_resolveExternLibTarget___closed__2 = _init_l_Lake_resolveExternLibTarget___closed__2(); +lean_mark_persistent(l_Lake_resolveExternLibTarget___closed__2); +l_Lake_resolveExternLibTarget___closed__3 = _init_l_Lake_resolveExternLibTarget___closed__3(); +lean_mark_persistent(l_Lake_resolveExternLibTarget___closed__3); +l_Lake_resolveExternLibTarget___closed__4 = _init_l_Lake_resolveExternLibTarget___closed__4(); +lean_mark_persistent(l_Lake_resolveExternLibTarget___closed__4); +l_Lake_resolveExternLibTarget___closed__5 = _init_l_Lake_resolveExternLibTarget___closed__5(); +lean_mark_persistent(l_Lake_resolveExternLibTarget___closed__5); +l_Lake_resolveDefaultPackageTarget___closed__1 = _init_l_Lake_resolveDefaultPackageTarget___closed__1(); +lean_mark_persistent(l_Lake_resolveDefaultPackageTarget___closed__1); +l_Lake_resolveDefaultPackageTarget___closed__2 = _init_l_Lake_resolveDefaultPackageTarget___closed__2(); +lean_mark_persistent(l_Lake_resolveDefaultPackageTarget___closed__2); +l_Lake_resolvePackageTarget___closed__1 = _init_l_Lake_resolvePackageTarget___closed__1(); +lean_mark_persistent(l_Lake_resolvePackageTarget___closed__1); +l_Lake_resolveTargetBaseSpec___closed__1 = _init_l_Lake_resolveTargetBaseSpec___closed__1(); +lean_mark_persistent(l_Lake_resolveTargetBaseSpec___closed__1); +l_Lake_resolveTargetBaseSpec___closed__2 = _init_l_Lake_resolveTargetBaseSpec___closed__2(); +lean_mark_persistent(l_Lake_resolveTargetBaseSpec___closed__2); +l_Lake_resolveTargetBaseSpec___closed__3 = _init_l_Lake_resolveTargetBaseSpec___closed__3(); +lean_mark_persistent(l_Lake_resolveTargetBaseSpec___closed__3); +l_Lake_resolveTargetBaseSpec___boxed__const__1 = _init_l_Lake_resolveTargetBaseSpec___boxed__const__1(); +lean_mark_persistent(l_Lake_resolveTargetBaseSpec___boxed__const__1); +l_Lake_parseExeTargetSpec___boxed__const__1 = _init_l_Lake_parseExeTargetSpec___boxed__const__1(); +lean_mark_persistent(l_Lake_parseExeTargetSpec___boxed__const__1); +l_Lake_parseTargetSpec___closed__1 = _init_l_Lake_parseTargetSpec___closed__1(); +lean_mark_persistent(l_Lake_parseTargetSpec___closed__1); +l_Lake_parseTargetSpec___boxed__const__1 = _init_l_Lake_parseTargetSpec___boxed__const__1(); +lean_mark_persistent(l_Lake_parseTargetSpec___boxed__const__1); +l_Lake_parseTargetSpecs___closed__1 = _init_l_Lake_parseTargetSpecs___closed__1(); +lean_mark_persistent(l_Lake_parseTargetSpecs___closed__1); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/CLI/Error.c b/stage0/stdlib/Lake/CLI/Error.c new file mode 100644 index 0000000000..d3b81a7eab --- /dev/null +++ b/stage0/stdlib/Lake/CLI/Error.c @@ -0,0 +1,4608 @@ +// Lean compiler output +// Module: Lake.CLI.Error +// Imports: Init +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__54; +lean_object* l_Lean_Name_reprPrec(lean_object*, lean_object*); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__13; +static lean_object* l_Lake_CliError_toString___closed__31; +static lean_object* l_Lake_CliError_toString___closed__6; +LEAN_EXPORT lean_object* l_Lake_instInhabitedCliError; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__14; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__56; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__8; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__74; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__76; +static lean_object* l_Lake_CliError_toString___closed__33; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__20; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__63; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__64; +static lean_object* l_Lake_CliError_toString___closed__27; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__71; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__25; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__83; +static lean_object* l_Lake_CliError_toString___closed__19; +static lean_object* l_Lake_CliError_toString___closed__16; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__50; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__95; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__9; +lean_object* l_String_quote(lean_object*); +lean_object* l_Lean_Name_toString(lean_object*, uint8_t); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__21; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__17; +LEAN_EXPORT lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____boxed(lean_object*, lean_object*); +static lean_object* l_Lake_CliError_toString___closed__32; +static lean_object* l_Lake_CliError_toString___closed__17; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__87; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__11; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__93; +static lean_object* l_Lake_CliError_toString___closed__10; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__60; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__31; +static lean_object* l_Lake_CliError_toString___closed__21; +static lean_object* l_Lake_CliError_toString___closed__1; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__19; +static lean_object* l_Lake_CliError_toString___closed__38; +LEAN_EXPORT lean_object* l_Lake_instReprCliError; +static lean_object* l_Lake_CliError_toString___closed__8; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__94; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__33; +lean_object* lean_string_push(lean_object*, uint32_t); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__47; +static lean_object* l_Lake_CliError_toString___closed__37; +static lean_object* l_Lake_CliError_toString___closed__34; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__97; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__82; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__75; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__26; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__62; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__18; +uint8_t l_String_isEmpty(lean_object*); +static lean_object* l_Lake_CliError_toString___closed__7; +static lean_object* l_Lake_CliError_toString___closed__22; +static lean_object* l_Lake_CliError_toString___closed__15; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__23; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__46; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__77; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__40; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__61; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__85; +lean_object* lean_nat_to_int(lean_object*); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__65; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__36; +static lean_object* l_Lake_CliError_instToString___closed__1; +static lean_object* l_Lake_CliError_toString___closed__18; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__44; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__52; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__22; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__78; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__72; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__55; +static lean_object* l_Lake_CliError_toString___closed__5; +LEAN_EXPORT lean_object* l_Lake_CliError_toString(lean_object*); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__42; +static lean_object* l_Lake_CliError_toString___closed__25; +lean_object* l_Char_quote(uint32_t); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__32; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__1; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__12; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__84; +static lean_object* l_Lake_CliError_toString___closed__13; +static lean_object* l_Lake_CliError_toString___closed__30; +lean_object* l_List_repr_x27___at___private_Init_Meta_0__Lean_Syntax_reprPreresolved____x40_Init_Meta___hyg_2008____spec__1(lean_object*, lean_object*); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__51; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__2; +static lean_object* l_Lake_CliError_toString___closed__3; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__39; +static lean_object* l_Lake_CliError_toString___closed__20; +LEAN_EXPORT lean_object* l_Lake_CliError_instToString; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__69; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__38; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__28; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__67; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__86; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__66; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__68; +static lean_object* l_Lake_CliError_toString___closed__39; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__53; +static lean_object* l_Lake_CliError_toString___closed__23; +static lean_object* l_Lake_CliError_toString___closed__36; +static lean_object* l_Lake_CliError_toString___closed__2; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__96; +static lean_object* l_Lake_CliError_toString___closed__9; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__57; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__43; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__5; +lean_object* l_Repr_addAppParen(lean_object*, lean_object*); +static lean_object* l_Lake_CliError_toString___closed__24; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__15; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__4; +static lean_object* l_Lake_CliError_toString___closed__14; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__45; +static lean_object* l_Lake_CliError_toString___closed__35; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__59; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__30; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__24; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__70; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__92; +lean_object* l_String_intercalate(lean_object*, lean_object*); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__35; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__79; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__90; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__29; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__7; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__10; +static lean_object* l_Lake_instReprCliError___closed__1; +static lean_object* l_Lake_CliError_toString___closed__12; +static lean_object* l_Lake_CliError_toString___closed__11; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__91; +lean_object* lean_string_append(lean_object*, lean_object*); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__58; +uint8_t lean_nat_dec_le(lean_object*, lean_object*); +static lean_object* l_Lake_CliError_toString___closed__26; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__41; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__73; +LEAN_EXPORT lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305_(lean_object*, lean_object*); +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__48; +static lean_object* l_Lake_CliError_toString___closed__4; +static lean_object* l_Lake_CliError_toString___closed__28; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__16; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__34; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__49; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__81; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__27; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__80; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__88; +static lean_object* l_Lake_CliError_toString___closed__29; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__37; +static lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__89; +static lean_object* _init_l_Lake_instInhabitedCliError() { +_start: +{ +lean_object* x_1; +x_1 = lean_box(0); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.missingCommand", 28); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__2() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__1; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(2u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__4() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_2 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__2; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__5() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__4; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = lean_unsigned_to_nat(1u); +x_2 = lean_nat_to_int(x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__7() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_2 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__2; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__8() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__7; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownCommand", 28); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__10() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__9; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__11() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__10; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__12() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.missingArg", 24); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__13() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__12; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__14() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__13; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__15() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.missingOptArg", 27); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__16() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__15; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__17() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__16; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__18() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownShortOption", 32); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__19() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__18; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__20() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__19; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__21() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownLongOption", 31); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__22() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__21; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__23() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__22; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__24() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unexpectedArguments", 33); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__25() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__24; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__26() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__25; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__27() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownTemplate", 29); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__28() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__27; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__29() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__28; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__30() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownConfigLang", 31); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__31() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__30; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__32() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__31; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__33() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownModule", 27); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__34() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__33; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__35() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__34; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__36() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownPackage", 28); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__37() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__36; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__38() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__37; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__39() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownFacet", 26); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__40() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__39; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__41() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__40; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__42() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownTarget", 27); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__43() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__42; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__44() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__43; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__45() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.missingModule", 27); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__46() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__45; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__47() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__46; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__48() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.missingTarget", 27); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__49() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__48; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__50() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__49; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__51() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.nonCliTarget", 26); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__52() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__51; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__53() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__52; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__54() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.nonCliFacet", 25); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__55() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__54; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__56() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__55; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__57() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.invalidTargetSpec", 31); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__58() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__57; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__59() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__58; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__60() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.invalidFacet", 26); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__61() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__60; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__62() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__61; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__63() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownExe", 24); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__64() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__63; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__65() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__64; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__66() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownScript", 27); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__67() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__66; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__68() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__67; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__69() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.missingScriptDoc", 30); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__70() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__69; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__71() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__70; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__72() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.invalidScriptSpec", 31); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__73() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__72; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__74() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__73; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__75() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.outputConfigExists", 32); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__76() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__75; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__77() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__76; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__78() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("FilePath.mk ", 12); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__79() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__78; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__80() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownLeanInstall", 32); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__81() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__80; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__82() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_2 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__81; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__83() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__82; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__84() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_2 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__81; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__85() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__84; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__86() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.unknownLakeInstall", 32); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__87() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__86; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__88() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_2 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__87; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__89() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__88; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__90() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_2 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__87; +x_3 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__91() { +_start: +{ +lean_object* x_1; uint8_t x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__90; +x_2 = 0; +x_3 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set_uint8(x_3, sizeof(void*)*1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__92() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.leanRevMismatch", 29); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__93() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__92; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__94() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__93; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__95() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("Lake.CliError.invalidEnv", 24); +return x_1; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__96() { +_start: +{ +lean_object* x_1; lean_object* x_2; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__95; +x_2 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_2, 0, x_1); +return x_2; +} +} +static lean_object* _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__97() { +_start: +{ +lean_object* x_1; lean_object* x_2; lean_object* x_3; +x_1 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__96; +x_2 = lean_box(1); +x_3 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_3, 0, x_1); +lean_ctor_set(x_3, 1, x_2); +return x_3; +} +} +LEAN_EXPORT lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305_(lean_object* x_1, lean_object* x_2) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_3; uint8_t x_4; +x_3 = lean_unsigned_to_nat(1024u); +x_4 = lean_nat_dec_le(x_3, x_2); +if (x_4 == 0) +{ +lean_object* x_5; lean_object* x_6; +x_5 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__5; +x_6 = l_Repr_addAppParen(x_5, x_2); +return x_6; +} +else +{ +lean_object* x_7; lean_object* x_8; +x_7 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__8; +x_8 = l_Repr_addAppParen(x_7, x_2); +return x_8; +} +} +case 1: +{ +uint8_t x_9; +x_9 = !lean_is_exclusive(x_1); +if (x_9 == 0) +{ +lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +x_10 = lean_ctor_get(x_1, 0); +x_11 = lean_unsigned_to_nat(1024u); +x_12 = lean_nat_dec_le(x_11, x_2); +x_13 = l_String_quote(x_10); +lean_dec(x_10); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_13); +x_14 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__11; +x_15 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_15, 0, x_14); +lean_ctor_set(x_15, 1, x_1); +if (x_12 == 0) +{ +lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; +x_16 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_17 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_17, 0, x_16); +lean_ctor_set(x_17, 1, x_15); +x_18 = 0; +x_19 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_19, 0, x_17); +lean_ctor_set_uint8(x_19, sizeof(void*)*1, x_18); +x_20 = l_Repr_addAppParen(x_19, x_2); +return x_20; +} +else +{ +lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_25; +x_21 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_22 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_22, 0, x_21); +lean_ctor_set(x_22, 1, x_15); +x_23 = 0; +x_24 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_24, 0, x_22); +lean_ctor_set_uint8(x_24, sizeof(void*)*1, x_23); +x_25 = l_Repr_addAppParen(x_24, x_2); +return x_25; +} +} +else +{ +lean_object* x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_26 = lean_ctor_get(x_1, 0); +lean_inc(x_26); +lean_dec(x_1); +x_27 = lean_unsigned_to_nat(1024u); +x_28 = lean_nat_dec_le(x_27, x_2); +x_29 = l_String_quote(x_26); +lean_dec(x_26); +x_30 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_30, 0, x_29); +x_31 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__11; +x_32 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_32, 0, x_31); +lean_ctor_set(x_32, 1, x_30); +if (x_28 == 0) +{ +lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; +x_33 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_34 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_32); +x_35 = 0; +x_36 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_36, 0, x_34); +lean_ctor_set_uint8(x_36, sizeof(void*)*1, x_35); +x_37 = l_Repr_addAppParen(x_36, x_2); +return x_37; +} +else +{ +lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_42; +x_38 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_39 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_32); +x_40 = 0; +x_41 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set_uint8(x_41, sizeof(void*)*1, x_40); +x_42 = l_Repr_addAppParen(x_41, x_2); +return x_42; +} +} +} +case 2: +{ +uint8_t x_43; +x_43 = !lean_is_exclusive(x_1); +if (x_43 == 0) +{ +lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; +x_44 = lean_ctor_get(x_1, 0); +x_45 = lean_unsigned_to_nat(1024u); +x_46 = lean_nat_dec_le(x_45, x_2); +x_47 = l_String_quote(x_44); +lean_dec(x_44); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_47); +x_48 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__14; +x_49 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_1); +if (x_46 == 0) +{ +lean_object* x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; +x_50 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_51 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_49); +x_52 = 0; +x_53 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set_uint8(x_53, sizeof(void*)*1, x_52); +x_54 = l_Repr_addAppParen(x_53, x_2); +return x_54; +} +else +{ +lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; +x_55 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_56 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_49); +x_57 = 0; +x_58 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_58, 0, x_56); +lean_ctor_set_uint8(x_58, sizeof(void*)*1, x_57); +x_59 = l_Repr_addAppParen(x_58, x_2); +return x_59; +} +} +else +{ +lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_1, 0); +lean_inc(x_60); +lean_dec(x_1); +x_61 = lean_unsigned_to_nat(1024u); +x_62 = lean_nat_dec_le(x_61, x_2); +x_63 = l_String_quote(x_60); +lean_dec(x_60); +x_64 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__14; +x_66 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_64); +if (x_62 == 0) +{ +lean_object* x_67; lean_object* x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; +x_67 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_68 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_68, 0, x_67); +lean_ctor_set(x_68, 1, x_66); +x_69 = 0; +x_70 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_70, 0, x_68); +lean_ctor_set_uint8(x_70, sizeof(void*)*1, x_69); +x_71 = l_Repr_addAppParen(x_70, x_2); +return x_71; +} +else +{ +lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; +x_72 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_73 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_66); +x_74 = 0; +x_75 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_75, 0, x_73); +lean_ctor_set_uint8(x_75, sizeof(void*)*1, x_74); +x_76 = l_Repr_addAppParen(x_75, x_2); +return x_76; +} +} +} +case 3: +{ +uint8_t x_77; +x_77 = !lean_is_exclusive(x_1); +if (x_77 == 0) +{ +lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_78 = lean_ctor_get(x_1, 0); +x_79 = lean_ctor_get(x_1, 1); +x_80 = lean_unsigned_to_nat(1024u); +x_81 = lean_nat_dec_le(x_80, x_2); +x_82 = l_String_quote(x_78); +lean_dec(x_78); +x_83 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_83, 0, x_82); +x_84 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__17; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_83); +lean_ctor_set(x_1, 0, x_84); +x_85 = lean_box(1); +x_86 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_86, 0, x_1); +lean_ctor_set(x_86, 1, x_85); +x_87 = l_String_quote(x_79); +lean_dec(x_79); +x_88 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_88, 0, x_87); +x_89 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_89, 0, x_86); +lean_ctor_set(x_89, 1, x_88); +if (x_81 == 0) +{ +lean_object* x_90; lean_object* x_91; uint8_t x_92; lean_object* x_93; lean_object* x_94; +x_90 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_91 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_91, 0, x_90); +lean_ctor_set(x_91, 1, x_89); +x_92 = 0; +x_93 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_93, 0, x_91); +lean_ctor_set_uint8(x_93, sizeof(void*)*1, x_92); +x_94 = l_Repr_addAppParen(x_93, x_2); +return x_94; +} +else +{ +lean_object* x_95; lean_object* x_96; uint8_t x_97; lean_object* x_98; lean_object* x_99; +x_95 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_96 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_89); +x_97 = 0; +x_98 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_98, 0, x_96); +lean_ctor_set_uint8(x_98, sizeof(void*)*1, x_97); +x_99 = l_Repr_addAppParen(x_98, x_2); +return x_99; +} +} +else +{ +lean_object* x_100; lean_object* x_101; lean_object* x_102; uint8_t x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_100 = lean_ctor_get(x_1, 0); +x_101 = lean_ctor_get(x_1, 1); +lean_inc(x_101); +lean_inc(x_100); +lean_dec(x_1); +x_102 = lean_unsigned_to_nat(1024u); +x_103 = lean_nat_dec_le(x_102, x_2); +x_104 = l_String_quote(x_100); +lean_dec(x_100); +x_105 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_105, 0, x_104); +x_106 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__17; +x_107 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_105); +x_108 = lean_box(1); +x_109 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_109, 0, x_107); +lean_ctor_set(x_109, 1, x_108); +x_110 = l_String_quote(x_101); +lean_dec(x_101); +x_111 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_111, 0, x_110); +x_112 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_112, 0, x_109); +lean_ctor_set(x_112, 1, x_111); +if (x_103 == 0) +{ +lean_object* x_113; lean_object* x_114; uint8_t x_115; lean_object* x_116; lean_object* x_117; +x_113 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_114 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_114, 0, x_113); +lean_ctor_set(x_114, 1, x_112); +x_115 = 0; +x_116 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set_uint8(x_116, sizeof(void*)*1, x_115); +x_117 = l_Repr_addAppParen(x_116, x_2); +return x_117; +} +else +{ +lean_object* x_118; lean_object* x_119; uint8_t x_120; lean_object* x_121; lean_object* x_122; +x_118 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_119 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_119, 0, x_118); +lean_ctor_set(x_119, 1, x_112); +x_120 = 0; +x_121 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_121, 0, x_119); +lean_ctor_set_uint8(x_121, sizeof(void*)*1, x_120); +x_122 = l_Repr_addAppParen(x_121, x_2); +return x_122; +} +} +} +case 4: +{ +uint8_t x_123; +x_123 = !lean_is_exclusive(x_1); +if (x_123 == 0) +{ +lean_object* x_124; lean_object* x_125; uint8_t x_126; uint32_t x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; +x_124 = lean_ctor_get(x_1, 0); +x_125 = lean_unsigned_to_nat(1024u); +x_126 = lean_nat_dec_le(x_125, x_2); +x_127 = lean_unbox_uint32(x_124); +lean_dec(x_124); +x_128 = l_Char_quote(x_127); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_128); +x_129 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__20; +x_130 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_130, 0, x_129); +lean_ctor_set(x_130, 1, x_1); +if (x_126 == 0) +{ +lean_object* x_131; lean_object* x_132; uint8_t x_133; lean_object* x_134; lean_object* x_135; +x_131 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_132 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_132, 0, x_131); +lean_ctor_set(x_132, 1, x_130); +x_133 = 0; +x_134 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_134, 0, x_132); +lean_ctor_set_uint8(x_134, sizeof(void*)*1, x_133); +x_135 = l_Repr_addAppParen(x_134, x_2); +return x_135; +} +else +{ +lean_object* x_136; lean_object* x_137; uint8_t x_138; lean_object* x_139; lean_object* x_140; +x_136 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_137 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_137, 0, x_136); +lean_ctor_set(x_137, 1, x_130); +x_138 = 0; +x_139 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_139, 0, x_137); +lean_ctor_set_uint8(x_139, sizeof(void*)*1, x_138); +x_140 = l_Repr_addAppParen(x_139, x_2); +return x_140; +} +} +else +{ +lean_object* x_141; lean_object* x_142; uint8_t x_143; uint32_t x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; +x_141 = lean_ctor_get(x_1, 0); +lean_inc(x_141); +lean_dec(x_1); +x_142 = lean_unsigned_to_nat(1024u); +x_143 = lean_nat_dec_le(x_142, x_2); +x_144 = lean_unbox_uint32(x_141); +lean_dec(x_141); +x_145 = l_Char_quote(x_144); +x_146 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_146, 0, x_145); +x_147 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__20; +x_148 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_148, 0, x_147); +lean_ctor_set(x_148, 1, x_146); +if (x_143 == 0) +{ +lean_object* x_149; lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; +x_149 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_150 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_150, 0, x_149); +lean_ctor_set(x_150, 1, x_148); +x_151 = 0; +x_152 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_152, 0, x_150); +lean_ctor_set_uint8(x_152, sizeof(void*)*1, x_151); +x_153 = l_Repr_addAppParen(x_152, x_2); +return x_153; +} +else +{ +lean_object* x_154; lean_object* x_155; uint8_t x_156; lean_object* x_157; lean_object* x_158; +x_154 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_155 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_155, 0, x_154); +lean_ctor_set(x_155, 1, x_148); +x_156 = 0; +x_157 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_157, 0, x_155); +lean_ctor_set_uint8(x_157, sizeof(void*)*1, x_156); +x_158 = l_Repr_addAppParen(x_157, x_2); +return x_158; +} +} +} +case 5: +{ +uint8_t x_159; +x_159 = !lean_is_exclusive(x_1); +if (x_159 == 0) +{ +lean_object* x_160; lean_object* x_161; uint8_t x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_160 = lean_ctor_get(x_1, 0); +x_161 = lean_unsigned_to_nat(1024u); +x_162 = lean_nat_dec_le(x_161, x_2); +x_163 = l_String_quote(x_160); +lean_dec(x_160); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_163); +x_164 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__23; +x_165 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_165, 0, x_164); +lean_ctor_set(x_165, 1, x_1); +if (x_162 == 0) +{ +lean_object* x_166; lean_object* x_167; uint8_t x_168; lean_object* x_169; lean_object* x_170; +x_166 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_167 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_167, 0, x_166); +lean_ctor_set(x_167, 1, x_165); +x_168 = 0; +x_169 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_169, 0, x_167); +lean_ctor_set_uint8(x_169, sizeof(void*)*1, x_168); +x_170 = l_Repr_addAppParen(x_169, x_2); +return x_170; +} +else +{ +lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; +x_171 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_172 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_172, 0, x_171); +lean_ctor_set(x_172, 1, x_165); +x_173 = 0; +x_174 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_174, 0, x_172); +lean_ctor_set_uint8(x_174, sizeof(void*)*1, x_173); +x_175 = l_Repr_addAppParen(x_174, x_2); +return x_175; +} +} +else +{ +lean_object* x_176; lean_object* x_177; uint8_t x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; +x_176 = lean_ctor_get(x_1, 0); +lean_inc(x_176); +lean_dec(x_1); +x_177 = lean_unsigned_to_nat(1024u); +x_178 = lean_nat_dec_le(x_177, x_2); +x_179 = l_String_quote(x_176); +lean_dec(x_176); +x_180 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_180, 0, x_179); +x_181 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__23; +x_182 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_182, 0, x_181); +lean_ctor_set(x_182, 1, x_180); +if (x_178 == 0) +{ +lean_object* x_183; lean_object* x_184; uint8_t x_185; lean_object* x_186; lean_object* x_187; +x_183 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_184 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_184, 0, x_183); +lean_ctor_set(x_184, 1, x_182); +x_185 = 0; +x_186 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_186, 0, x_184); +lean_ctor_set_uint8(x_186, sizeof(void*)*1, x_185); +x_187 = l_Repr_addAppParen(x_186, x_2); +return x_187; +} +else +{ +lean_object* x_188; lean_object* x_189; uint8_t x_190; lean_object* x_191; lean_object* x_192; +x_188 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_189 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_189, 0, x_188); +lean_ctor_set(x_189, 1, x_182); +x_190 = 0; +x_191 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_191, 0, x_189); +lean_ctor_set_uint8(x_191, sizeof(void*)*1, x_190); +x_192 = l_Repr_addAppParen(x_191, x_2); +return x_192; +} +} +} +case 6: +{ +lean_object* x_193; lean_object* x_194; uint8_t x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; +x_193 = lean_ctor_get(x_1, 0); +lean_inc(x_193); +lean_dec(x_1); +x_194 = lean_unsigned_to_nat(1024u); +x_195 = lean_nat_dec_le(x_194, x_2); +x_196 = l_List_repr_x27___at___private_Init_Meta_0__Lean_Syntax_reprPreresolved____x40_Init_Meta___hyg_2008____spec__1(x_193, x_194); +x_197 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__26; +x_198 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_198, 0, x_197); +lean_ctor_set(x_198, 1, x_196); +if (x_195 == 0) +{ +lean_object* x_199; lean_object* x_200; uint8_t x_201; lean_object* x_202; lean_object* x_203; +x_199 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_200 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_200, 0, x_199); +lean_ctor_set(x_200, 1, x_198); +x_201 = 0; +x_202 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_202, 0, x_200); +lean_ctor_set_uint8(x_202, sizeof(void*)*1, x_201); +x_203 = l_Repr_addAppParen(x_202, x_2); +return x_203; +} +else +{ +lean_object* x_204; lean_object* x_205; uint8_t x_206; lean_object* x_207; lean_object* x_208; +x_204 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_205 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_205, 0, x_204); +lean_ctor_set(x_205, 1, x_198); +x_206 = 0; +x_207 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_207, 0, x_205); +lean_ctor_set_uint8(x_207, sizeof(void*)*1, x_206); +x_208 = l_Repr_addAppParen(x_207, x_2); +return x_208; +} +} +case 7: +{ +uint8_t x_209; +x_209 = !lean_is_exclusive(x_1); +if (x_209 == 0) +{ +lean_object* x_210; lean_object* x_211; uint8_t x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_210 = lean_ctor_get(x_1, 0); +x_211 = lean_unsigned_to_nat(1024u); +x_212 = lean_nat_dec_le(x_211, x_2); +x_213 = l_String_quote(x_210); +lean_dec(x_210); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_213); +x_214 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__29; +x_215 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_215, 0, x_214); +lean_ctor_set(x_215, 1, x_1); +if (x_212 == 0) +{ +lean_object* x_216; lean_object* x_217; uint8_t x_218; lean_object* x_219; lean_object* x_220; +x_216 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_217 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_217, 0, x_216); +lean_ctor_set(x_217, 1, x_215); +x_218 = 0; +x_219 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_219, 0, x_217); +lean_ctor_set_uint8(x_219, sizeof(void*)*1, x_218); +x_220 = l_Repr_addAppParen(x_219, x_2); +return x_220; +} +else +{ +lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; lean_object* x_225; +x_221 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_222 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_222, 0, x_221); +lean_ctor_set(x_222, 1, x_215); +x_223 = 0; +x_224 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_224, 0, x_222); +lean_ctor_set_uint8(x_224, sizeof(void*)*1, x_223); +x_225 = l_Repr_addAppParen(x_224, x_2); +return x_225; +} +} +else +{ +lean_object* x_226; lean_object* x_227; uint8_t x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; +x_226 = lean_ctor_get(x_1, 0); +lean_inc(x_226); +lean_dec(x_1); +x_227 = lean_unsigned_to_nat(1024u); +x_228 = lean_nat_dec_le(x_227, x_2); +x_229 = l_String_quote(x_226); +lean_dec(x_226); +x_230 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_230, 0, x_229); +x_231 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__29; +x_232 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_230); +if (x_228 == 0) +{ +lean_object* x_233; lean_object* x_234; uint8_t x_235; lean_object* x_236; lean_object* x_237; +x_233 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_234 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_234, 0, x_233); +lean_ctor_set(x_234, 1, x_232); +x_235 = 0; +x_236 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_236, 0, x_234); +lean_ctor_set_uint8(x_236, sizeof(void*)*1, x_235); +x_237 = l_Repr_addAppParen(x_236, x_2); +return x_237; +} +else +{ +lean_object* x_238; lean_object* x_239; uint8_t x_240; lean_object* x_241; lean_object* x_242; +x_238 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_239 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_239, 0, x_238); +lean_ctor_set(x_239, 1, x_232); +x_240 = 0; +x_241 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_241, 0, x_239); +lean_ctor_set_uint8(x_241, sizeof(void*)*1, x_240); +x_242 = l_Repr_addAppParen(x_241, x_2); +return x_242; +} +} +} +case 8: +{ +uint8_t x_243; +x_243 = !lean_is_exclusive(x_1); +if (x_243 == 0) +{ +lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; +x_244 = lean_ctor_get(x_1, 0); +x_245 = lean_unsigned_to_nat(1024u); +x_246 = lean_nat_dec_le(x_245, x_2); +x_247 = l_String_quote(x_244); +lean_dec(x_244); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_247); +x_248 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__32; +x_249 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_249, 0, x_248); +lean_ctor_set(x_249, 1, x_1); +if (x_246 == 0) +{ +lean_object* x_250; lean_object* x_251; uint8_t x_252; lean_object* x_253; lean_object* x_254; +x_250 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_251 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_251, 0, x_250); +lean_ctor_set(x_251, 1, x_249); +x_252 = 0; +x_253 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_253, 0, x_251); +lean_ctor_set_uint8(x_253, sizeof(void*)*1, x_252); +x_254 = l_Repr_addAppParen(x_253, x_2); +return x_254; +} +else +{ +lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; lean_object* x_259; +x_255 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_256 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_256, 0, x_255); +lean_ctor_set(x_256, 1, x_249); +x_257 = 0; +x_258 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_258, 0, x_256); +lean_ctor_set_uint8(x_258, sizeof(void*)*1, x_257); +x_259 = l_Repr_addAppParen(x_258, x_2); +return x_259; +} +} +else +{ +lean_object* x_260; lean_object* x_261; uint8_t x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; +x_260 = lean_ctor_get(x_1, 0); +lean_inc(x_260); +lean_dec(x_1); +x_261 = lean_unsigned_to_nat(1024u); +x_262 = lean_nat_dec_le(x_261, x_2); +x_263 = l_String_quote(x_260); +lean_dec(x_260); +x_264 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_264, 0, x_263); +x_265 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__32; +x_266 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_266, 0, x_265); +lean_ctor_set(x_266, 1, x_264); +if (x_262 == 0) +{ +lean_object* x_267; lean_object* x_268; uint8_t x_269; lean_object* x_270; lean_object* x_271; +x_267 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_268 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_268, 0, x_267); +lean_ctor_set(x_268, 1, x_266); +x_269 = 0; +x_270 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_270, 0, x_268); +lean_ctor_set_uint8(x_270, sizeof(void*)*1, x_269); +x_271 = l_Repr_addAppParen(x_270, x_2); +return x_271; +} +else +{ +lean_object* x_272; lean_object* x_273; uint8_t x_274; lean_object* x_275; lean_object* x_276; +x_272 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_273 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_273, 0, x_272); +lean_ctor_set(x_273, 1, x_266); +x_274 = 0; +x_275 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_275, 0, x_273); +lean_ctor_set_uint8(x_275, sizeof(void*)*1, x_274); +x_276 = l_Repr_addAppParen(x_275, x_2); +return x_276; +} +} +} +case 9: +{ +lean_object* x_277; lean_object* x_278; uint8_t x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; +x_277 = lean_ctor_get(x_1, 0); +lean_inc(x_277); +lean_dec(x_1); +x_278 = lean_unsigned_to_nat(1024u); +x_279 = lean_nat_dec_le(x_278, x_2); +x_280 = l_Lean_Name_reprPrec(x_277, x_278); +x_281 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__35; +x_282 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_282, 0, x_281); +lean_ctor_set(x_282, 1, x_280); +if (x_279 == 0) +{ +lean_object* x_283; lean_object* x_284; uint8_t x_285; lean_object* x_286; lean_object* x_287; +x_283 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_284 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_284, 0, x_283); +lean_ctor_set(x_284, 1, x_282); +x_285 = 0; +x_286 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_286, 0, x_284); +lean_ctor_set_uint8(x_286, sizeof(void*)*1, x_285); +x_287 = l_Repr_addAppParen(x_286, x_2); +return x_287; +} +else +{ +lean_object* x_288; lean_object* x_289; uint8_t x_290; lean_object* x_291; lean_object* x_292; +x_288 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_289 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_289, 0, x_288); +lean_ctor_set(x_289, 1, x_282); +x_290 = 0; +x_291 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_291, 0, x_289); +lean_ctor_set_uint8(x_291, sizeof(void*)*1, x_290); +x_292 = l_Repr_addAppParen(x_291, x_2); +return x_292; +} +} +case 10: +{ +uint8_t x_293; +x_293 = !lean_is_exclusive(x_1); +if (x_293 == 0) +{ +lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; +x_294 = lean_ctor_get(x_1, 0); +x_295 = lean_unsigned_to_nat(1024u); +x_296 = lean_nat_dec_le(x_295, x_2); +x_297 = l_String_quote(x_294); +lean_dec(x_294); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_297); +x_298 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__38; +x_299 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_299, 0, x_298); +lean_ctor_set(x_299, 1, x_1); +if (x_296 == 0) +{ +lean_object* x_300; lean_object* x_301; uint8_t x_302; lean_object* x_303; lean_object* x_304; +x_300 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_301 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_301, 0, x_300); +lean_ctor_set(x_301, 1, x_299); +x_302 = 0; +x_303 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_303, 0, x_301); +lean_ctor_set_uint8(x_303, sizeof(void*)*1, x_302); +x_304 = l_Repr_addAppParen(x_303, x_2); +return x_304; +} +else +{ +lean_object* x_305; lean_object* x_306; uint8_t x_307; lean_object* x_308; lean_object* x_309; +x_305 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_306 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_306, 0, x_305); +lean_ctor_set(x_306, 1, x_299); +x_307 = 0; +x_308 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_308, 0, x_306); +lean_ctor_set_uint8(x_308, sizeof(void*)*1, x_307); +x_309 = l_Repr_addAppParen(x_308, x_2); +return x_309; +} +} +else +{ +lean_object* x_310; lean_object* x_311; uint8_t x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; +x_310 = lean_ctor_get(x_1, 0); +lean_inc(x_310); +lean_dec(x_1); +x_311 = lean_unsigned_to_nat(1024u); +x_312 = lean_nat_dec_le(x_311, x_2); +x_313 = l_String_quote(x_310); +lean_dec(x_310); +x_314 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_314, 0, x_313); +x_315 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__38; +x_316 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_316, 0, x_315); +lean_ctor_set(x_316, 1, x_314); +if (x_312 == 0) +{ +lean_object* x_317; lean_object* x_318; uint8_t x_319; lean_object* x_320; lean_object* x_321; +x_317 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_318 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_318, 0, x_317); +lean_ctor_set(x_318, 1, x_316); +x_319 = 0; +x_320 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_320, 0, x_318); +lean_ctor_set_uint8(x_320, sizeof(void*)*1, x_319); +x_321 = l_Repr_addAppParen(x_320, x_2); +return x_321; +} +else +{ +lean_object* x_322; lean_object* x_323; uint8_t x_324; lean_object* x_325; lean_object* x_326; +x_322 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_323 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_323, 0, x_322); +lean_ctor_set(x_323, 1, x_316); +x_324 = 0; +x_325 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_325, 0, x_323); +lean_ctor_set_uint8(x_325, sizeof(void*)*1, x_324); +x_326 = l_Repr_addAppParen(x_325, x_2); +return x_326; +} +} +} +case 11: +{ +uint8_t x_327; +x_327 = !lean_is_exclusive(x_1); +if (x_327 == 0) +{ +lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t 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; +x_328 = lean_ctor_get(x_1, 0); +x_329 = lean_ctor_get(x_1, 1); +x_330 = lean_unsigned_to_nat(1024u); +x_331 = lean_nat_dec_le(x_330, x_2); +x_332 = l_String_quote(x_328); +lean_dec(x_328); +x_333 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_333, 0, x_332); +x_334 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__41; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_333); +lean_ctor_set(x_1, 0, x_334); +x_335 = lean_box(1); +x_336 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_336, 0, x_1); +lean_ctor_set(x_336, 1, x_335); +x_337 = l_Lean_Name_reprPrec(x_329, x_330); +x_338 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_338, 0, x_336); +lean_ctor_set(x_338, 1, x_337); +if (x_331 == 0) +{ +lean_object* x_339; lean_object* x_340; uint8_t x_341; lean_object* x_342; lean_object* x_343; +x_339 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_340 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_340, 0, x_339); +lean_ctor_set(x_340, 1, x_338); +x_341 = 0; +x_342 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_342, 0, x_340); +lean_ctor_set_uint8(x_342, sizeof(void*)*1, x_341); +x_343 = l_Repr_addAppParen(x_342, x_2); +return x_343; +} +else +{ +lean_object* x_344; lean_object* x_345; uint8_t x_346; lean_object* x_347; lean_object* x_348; +x_344 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_345 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_345, 0, x_344); +lean_ctor_set(x_345, 1, x_338); +x_346 = 0; +x_347 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_347, 0, x_345); +lean_ctor_set_uint8(x_347, sizeof(void*)*1, x_346); +x_348 = l_Repr_addAppParen(x_347, x_2); +return x_348; +} +} +else +{ +lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t 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; +x_349 = lean_ctor_get(x_1, 0); +x_350 = lean_ctor_get(x_1, 1); +lean_inc(x_350); +lean_inc(x_349); +lean_dec(x_1); +x_351 = lean_unsigned_to_nat(1024u); +x_352 = lean_nat_dec_le(x_351, x_2); +x_353 = l_String_quote(x_349); +lean_dec(x_349); +x_354 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_354, 0, x_353); +x_355 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__41; +x_356 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_356, 0, x_355); +lean_ctor_set(x_356, 1, x_354); +x_357 = lean_box(1); +x_358 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_358, 0, x_356); +lean_ctor_set(x_358, 1, x_357); +x_359 = l_Lean_Name_reprPrec(x_350, x_351); +x_360 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_360, 0, x_358); +lean_ctor_set(x_360, 1, x_359); +if (x_352 == 0) +{ +lean_object* x_361; lean_object* x_362; uint8_t x_363; lean_object* x_364; lean_object* x_365; +x_361 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_362 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_362, 0, x_361); +lean_ctor_set(x_362, 1, x_360); +x_363 = 0; +x_364 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_364, 0, x_362); +lean_ctor_set_uint8(x_364, sizeof(void*)*1, x_363); +x_365 = l_Repr_addAppParen(x_364, x_2); +return x_365; +} +else +{ +lean_object* x_366; lean_object* x_367; uint8_t x_368; lean_object* x_369; lean_object* x_370; +x_366 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_367 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_367, 0, x_366); +lean_ctor_set(x_367, 1, x_360); +x_368 = 0; +x_369 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_369, 0, x_367); +lean_ctor_set_uint8(x_369, sizeof(void*)*1, x_368); +x_370 = l_Repr_addAppParen(x_369, x_2); +return x_370; +} +} +} +case 12: +{ +lean_object* x_371; lean_object* x_372; uint8_t x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; +x_371 = lean_ctor_get(x_1, 0); +lean_inc(x_371); +lean_dec(x_1); +x_372 = lean_unsigned_to_nat(1024u); +x_373 = lean_nat_dec_le(x_372, x_2); +x_374 = l_Lean_Name_reprPrec(x_371, x_372); +x_375 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__44; +x_376 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_376, 0, x_375); +lean_ctor_set(x_376, 1, x_374); +if (x_373 == 0) +{ +lean_object* x_377; lean_object* x_378; uint8_t x_379; lean_object* x_380; lean_object* x_381; +x_377 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_378 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_378, 0, x_377); +lean_ctor_set(x_378, 1, x_376); +x_379 = 0; +x_380 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_380, 0, x_378); +lean_ctor_set_uint8(x_380, sizeof(void*)*1, x_379); +x_381 = l_Repr_addAppParen(x_380, x_2); +return x_381; +} +else +{ +lean_object* x_382; lean_object* x_383; uint8_t x_384; lean_object* x_385; lean_object* x_386; +x_382 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_383 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_383, 0, x_382); +lean_ctor_set(x_383, 1, x_376); +x_384 = 0; +x_385 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_385, 0, x_383); +lean_ctor_set_uint8(x_385, sizeof(void*)*1, x_384); +x_386 = l_Repr_addAppParen(x_385, x_2); +return x_386; +} +} +case 13: +{ +uint8_t x_387; +x_387 = !lean_is_exclusive(x_1); +if (x_387 == 0) +{ +lean_object* x_388; lean_object* x_389; lean_object* x_390; uint8_t x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; +x_388 = lean_ctor_get(x_1, 0); +x_389 = lean_ctor_get(x_1, 1); +x_390 = lean_unsigned_to_nat(1024u); +x_391 = lean_nat_dec_le(x_390, x_2); +x_392 = l_Lean_Name_reprPrec(x_388, x_390); +x_393 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__47; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_392); +lean_ctor_set(x_1, 0, x_393); +x_394 = lean_box(1); +x_395 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_395, 0, x_1); +lean_ctor_set(x_395, 1, x_394); +x_396 = l_Lean_Name_reprPrec(x_389, x_390); +x_397 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_397, 0, x_395); +lean_ctor_set(x_397, 1, x_396); +if (x_391 == 0) +{ +lean_object* x_398; lean_object* x_399; uint8_t x_400; lean_object* x_401; lean_object* x_402; +x_398 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_399 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_399, 0, x_398); +lean_ctor_set(x_399, 1, x_397); +x_400 = 0; +x_401 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_401, 0, x_399); +lean_ctor_set_uint8(x_401, sizeof(void*)*1, x_400); +x_402 = l_Repr_addAppParen(x_401, x_2); +return x_402; +} +else +{ +lean_object* x_403; lean_object* x_404; uint8_t x_405; lean_object* x_406; lean_object* x_407; +x_403 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_404 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_404, 0, x_403); +lean_ctor_set(x_404, 1, x_397); +x_405 = 0; +x_406 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_406, 0, x_404); +lean_ctor_set_uint8(x_406, sizeof(void*)*1, x_405); +x_407 = l_Repr_addAppParen(x_406, x_2); +return x_407; +} +} +else +{ +lean_object* x_408; lean_object* x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; +x_408 = lean_ctor_get(x_1, 0); +x_409 = lean_ctor_get(x_1, 1); +lean_inc(x_409); +lean_inc(x_408); +lean_dec(x_1); +x_410 = lean_unsigned_to_nat(1024u); +x_411 = lean_nat_dec_le(x_410, x_2); +x_412 = l_Lean_Name_reprPrec(x_408, x_410); +x_413 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__47; +x_414 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_414, 0, x_413); +lean_ctor_set(x_414, 1, x_412); +x_415 = lean_box(1); +x_416 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_416, 0, x_414); +lean_ctor_set(x_416, 1, x_415); +x_417 = l_Lean_Name_reprPrec(x_409, x_410); +x_418 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_418, 0, x_416); +lean_ctor_set(x_418, 1, x_417); +if (x_411 == 0) +{ +lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; lean_object* x_423; +x_419 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_420 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_420, 0, x_419); +lean_ctor_set(x_420, 1, x_418); +x_421 = 0; +x_422 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_422, 0, x_420); +lean_ctor_set_uint8(x_422, sizeof(void*)*1, x_421); +x_423 = l_Repr_addAppParen(x_422, x_2); +return x_423; +} +else +{ +lean_object* x_424; lean_object* x_425; uint8_t x_426; lean_object* x_427; lean_object* x_428; +x_424 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_425 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_425, 0, x_424); +lean_ctor_set(x_425, 1, x_418); +x_426 = 0; +x_427 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_427, 0, x_425); +lean_ctor_set_uint8(x_427, sizeof(void*)*1, x_426); +x_428 = l_Repr_addAppParen(x_427, x_2); +return x_428; +} +} +} +case 14: +{ +uint8_t x_429; +x_429 = !lean_is_exclusive(x_1); +if (x_429 == 0) +{ +lean_object* x_430; lean_object* x_431; lean_object* x_432; uint8_t x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; +x_430 = lean_ctor_get(x_1, 0); +x_431 = lean_ctor_get(x_1, 1); +x_432 = lean_unsigned_to_nat(1024u); +x_433 = lean_nat_dec_le(x_432, x_2); +x_434 = l_Lean_Name_reprPrec(x_430, x_432); +x_435 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__50; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_434); +lean_ctor_set(x_1, 0, x_435); +x_436 = lean_box(1); +x_437 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_437, 0, x_1); +lean_ctor_set(x_437, 1, x_436); +x_438 = l_String_quote(x_431); +lean_dec(x_431); +x_439 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_439, 0, x_438); +x_440 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_440, 0, x_437); +lean_ctor_set(x_440, 1, x_439); +if (x_433 == 0) +{ +lean_object* x_441; lean_object* x_442; uint8_t x_443; lean_object* x_444; lean_object* x_445; +x_441 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_442 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_442, 0, x_441); +lean_ctor_set(x_442, 1, x_440); +x_443 = 0; +x_444 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_444, 0, x_442); +lean_ctor_set_uint8(x_444, sizeof(void*)*1, x_443); +x_445 = l_Repr_addAppParen(x_444, x_2); +return x_445; +} +else +{ +lean_object* x_446; lean_object* x_447; uint8_t x_448; lean_object* x_449; lean_object* x_450; +x_446 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_447 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_447, 0, x_446); +lean_ctor_set(x_447, 1, x_440); +x_448 = 0; +x_449 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_449, 0, x_447); +lean_ctor_set_uint8(x_449, sizeof(void*)*1, x_448); +x_450 = l_Repr_addAppParen(x_449, x_2); +return x_450; +} +} +else +{ +lean_object* x_451; lean_object* x_452; lean_object* x_453; uint8_t 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; +x_451 = lean_ctor_get(x_1, 0); +x_452 = lean_ctor_get(x_1, 1); +lean_inc(x_452); +lean_inc(x_451); +lean_dec(x_1); +x_453 = lean_unsigned_to_nat(1024u); +x_454 = lean_nat_dec_le(x_453, x_2); +x_455 = l_Lean_Name_reprPrec(x_451, x_453); +x_456 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__50; +x_457 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_457, 0, x_456); +lean_ctor_set(x_457, 1, x_455); +x_458 = lean_box(1); +x_459 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_459, 0, x_457); +lean_ctor_set(x_459, 1, x_458); +x_460 = l_String_quote(x_452); +lean_dec(x_452); +x_461 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_461, 0, x_460); +x_462 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_462, 0, x_459); +lean_ctor_set(x_462, 1, x_461); +if (x_454 == 0) +{ +lean_object* x_463; lean_object* x_464; uint8_t x_465; lean_object* x_466; lean_object* x_467; +x_463 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_464 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_464, 0, x_463); +lean_ctor_set(x_464, 1, x_462); +x_465 = 0; +x_466 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_466, 0, x_464); +lean_ctor_set_uint8(x_466, sizeof(void*)*1, x_465); +x_467 = l_Repr_addAppParen(x_466, x_2); +return x_467; +} +else +{ +lean_object* x_468; lean_object* x_469; uint8_t x_470; lean_object* x_471; lean_object* x_472; +x_468 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_469 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_469, 0, x_468); +lean_ctor_set(x_469, 1, x_462); +x_470 = 0; +x_471 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_471, 0, x_469); +lean_ctor_set_uint8(x_471, sizeof(void*)*1, x_470); +x_472 = l_Repr_addAppParen(x_471, x_2); +return x_472; +} +} +} +case 15: +{ +lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; +x_473 = lean_ctor_get(x_1, 0); +lean_inc(x_473); +lean_dec(x_1); +x_474 = lean_unsigned_to_nat(1024u); +x_475 = lean_nat_dec_le(x_474, x_2); +x_476 = l_Lean_Name_reprPrec(x_473, x_474); +x_477 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__53; +x_478 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_478, 0, x_477); +lean_ctor_set(x_478, 1, x_476); +if (x_475 == 0) +{ +lean_object* x_479; lean_object* x_480; uint8_t x_481; lean_object* x_482; lean_object* x_483; +x_479 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_480 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_480, 0, x_479); +lean_ctor_set(x_480, 1, x_478); +x_481 = 0; +x_482 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_482, 0, x_480); +lean_ctor_set_uint8(x_482, sizeof(void*)*1, x_481); +x_483 = l_Repr_addAppParen(x_482, x_2); +return x_483; +} +else +{ +lean_object* x_484; lean_object* x_485; uint8_t x_486; lean_object* x_487; lean_object* x_488; +x_484 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_485 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_485, 0, x_484); +lean_ctor_set(x_485, 1, x_478); +x_486 = 0; +x_487 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_487, 0, x_485); +lean_ctor_set_uint8(x_487, sizeof(void*)*1, x_486); +x_488 = l_Repr_addAppParen(x_487, x_2); +return x_488; +} +} +case 16: +{ +uint8_t x_489; +x_489 = !lean_is_exclusive(x_1); +if (x_489 == 0) +{ +lean_object* x_490; lean_object* x_491; lean_object* x_492; uint8_t x_493; lean_object* x_494; lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; +x_490 = lean_ctor_get(x_1, 0); +x_491 = lean_ctor_get(x_1, 1); +x_492 = lean_unsigned_to_nat(1024u); +x_493 = lean_nat_dec_le(x_492, x_2); +x_494 = l_String_quote(x_490); +lean_dec(x_490); +x_495 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_495, 0, x_494); +x_496 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__56; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_495); +lean_ctor_set(x_1, 0, x_496); +x_497 = lean_box(1); +x_498 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_498, 0, x_1); +lean_ctor_set(x_498, 1, x_497); +x_499 = l_Lean_Name_reprPrec(x_491, x_492); +x_500 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_500, 0, x_498); +lean_ctor_set(x_500, 1, x_499); +if (x_493 == 0) +{ +lean_object* x_501; lean_object* x_502; uint8_t x_503; lean_object* x_504; lean_object* x_505; +x_501 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_502 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_502, 0, x_501); +lean_ctor_set(x_502, 1, x_500); +x_503 = 0; +x_504 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_504, 0, x_502); +lean_ctor_set_uint8(x_504, sizeof(void*)*1, x_503); +x_505 = l_Repr_addAppParen(x_504, x_2); +return x_505; +} +else +{ +lean_object* x_506; lean_object* x_507; uint8_t x_508; lean_object* x_509; lean_object* x_510; +x_506 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_507 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_507, 0, x_506); +lean_ctor_set(x_507, 1, x_500); +x_508 = 0; +x_509 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_509, 0, x_507); +lean_ctor_set_uint8(x_509, sizeof(void*)*1, x_508); +x_510 = l_Repr_addAppParen(x_509, x_2); +return x_510; +} +} +else +{ +lean_object* x_511; lean_object* x_512; lean_object* x_513; uint8_t x_514; lean_object* x_515; lean_object* x_516; lean_object* x_517; lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; +x_511 = lean_ctor_get(x_1, 0); +x_512 = lean_ctor_get(x_1, 1); +lean_inc(x_512); +lean_inc(x_511); +lean_dec(x_1); +x_513 = lean_unsigned_to_nat(1024u); +x_514 = lean_nat_dec_le(x_513, x_2); +x_515 = l_String_quote(x_511); +lean_dec(x_511); +x_516 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_516, 0, x_515); +x_517 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__56; +x_518 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_518, 0, x_517); +lean_ctor_set(x_518, 1, x_516); +x_519 = lean_box(1); +x_520 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_520, 0, x_518); +lean_ctor_set(x_520, 1, x_519); +x_521 = l_Lean_Name_reprPrec(x_512, x_513); +x_522 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_522, 0, x_520); +lean_ctor_set(x_522, 1, x_521); +if (x_514 == 0) +{ +lean_object* x_523; lean_object* x_524; uint8_t x_525; lean_object* x_526; lean_object* x_527; +x_523 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_524 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_524, 0, x_523); +lean_ctor_set(x_524, 1, x_522); +x_525 = 0; +x_526 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_526, 0, x_524); +lean_ctor_set_uint8(x_526, sizeof(void*)*1, x_525); +x_527 = l_Repr_addAppParen(x_526, x_2); +return x_527; +} +else +{ +lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; lean_object* x_532; +x_528 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_529 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_529, 0, x_528); +lean_ctor_set(x_529, 1, x_522); +x_530 = 0; +x_531 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_531, 0, x_529); +lean_ctor_set_uint8(x_531, sizeof(void*)*1, x_530); +x_532 = l_Repr_addAppParen(x_531, x_2); +return x_532; +} +} +} +case 17: +{ +uint8_t x_533; +x_533 = !lean_is_exclusive(x_1); +if (x_533 == 0) +{ +lean_object* x_534; lean_object* x_535; lean_object* x_536; uint8_t x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; uint32_t x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; +x_534 = lean_ctor_get(x_1, 0); +x_535 = lean_ctor_get(x_1, 1); +x_536 = lean_unsigned_to_nat(1024u); +x_537 = lean_nat_dec_le(x_536, x_2); +x_538 = l_String_quote(x_534); +lean_dec(x_534); +x_539 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_539, 0, x_538); +x_540 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__59; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_539); +lean_ctor_set(x_1, 0, x_540); +x_541 = lean_box(1); +x_542 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_542, 0, x_1); +lean_ctor_set(x_542, 1, x_541); +x_543 = lean_unbox_uint32(x_535); +lean_dec(x_535); +x_544 = l_Char_quote(x_543); +x_545 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_545, 0, x_544); +x_546 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_546, 0, x_542); +lean_ctor_set(x_546, 1, x_545); +if (x_537 == 0) +{ +lean_object* x_547; lean_object* x_548; uint8_t x_549; lean_object* x_550; lean_object* x_551; +x_547 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_548 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_548, 0, x_547); +lean_ctor_set(x_548, 1, x_546); +x_549 = 0; +x_550 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_550, 0, x_548); +lean_ctor_set_uint8(x_550, sizeof(void*)*1, x_549); +x_551 = l_Repr_addAppParen(x_550, x_2); +return x_551; +} +else +{ +lean_object* x_552; lean_object* x_553; uint8_t x_554; lean_object* x_555; lean_object* x_556; +x_552 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_553 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_553, 0, x_552); +lean_ctor_set(x_553, 1, x_546); +x_554 = 0; +x_555 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_555, 0, x_553); +lean_ctor_set_uint8(x_555, sizeof(void*)*1, x_554); +x_556 = l_Repr_addAppParen(x_555, x_2); +return x_556; +} +} +else +{ +lean_object* x_557; lean_object* x_558; lean_object* x_559; uint8_t x_560; lean_object* x_561; lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; uint32_t x_567; lean_object* x_568; lean_object* x_569; lean_object* x_570; +x_557 = lean_ctor_get(x_1, 0); +x_558 = lean_ctor_get(x_1, 1); +lean_inc(x_558); +lean_inc(x_557); +lean_dec(x_1); +x_559 = lean_unsigned_to_nat(1024u); +x_560 = lean_nat_dec_le(x_559, x_2); +x_561 = l_String_quote(x_557); +lean_dec(x_557); +x_562 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_562, 0, x_561); +x_563 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__59; +x_564 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_564, 0, x_563); +lean_ctor_set(x_564, 1, x_562); +x_565 = lean_box(1); +x_566 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_566, 0, x_564); +lean_ctor_set(x_566, 1, x_565); +x_567 = lean_unbox_uint32(x_558); +lean_dec(x_558); +x_568 = l_Char_quote(x_567); +x_569 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_569, 0, x_568); +x_570 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_570, 0, x_566); +lean_ctor_set(x_570, 1, x_569); +if (x_560 == 0) +{ +lean_object* x_571; lean_object* x_572; uint8_t x_573; lean_object* x_574; lean_object* x_575; +x_571 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_572 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_572, 0, x_571); +lean_ctor_set(x_572, 1, x_570); +x_573 = 0; +x_574 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_574, 0, x_572); +lean_ctor_set_uint8(x_574, sizeof(void*)*1, x_573); +x_575 = l_Repr_addAppParen(x_574, x_2); +return x_575; +} +else +{ +lean_object* x_576; lean_object* x_577; uint8_t x_578; lean_object* x_579; lean_object* x_580; +x_576 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_577 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_577, 0, x_576); +lean_ctor_set(x_577, 1, x_570); +x_578 = 0; +x_579 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_579, 0, x_577); +lean_ctor_set_uint8(x_579, sizeof(void*)*1, x_578); +x_580 = l_Repr_addAppParen(x_579, x_2); +return x_580; +} +} +} +case 18: +{ +uint8_t x_581; +x_581 = !lean_is_exclusive(x_1); +if (x_581 == 0) +{ +lean_object* x_582; lean_object* x_583; lean_object* x_584; uint8_t x_585; lean_object* x_586; lean_object* x_587; lean_object* x_588; lean_object* x_589; lean_object* x_590; lean_object* x_591; +x_582 = lean_ctor_get(x_1, 0); +x_583 = lean_ctor_get(x_1, 1); +x_584 = lean_unsigned_to_nat(1024u); +x_585 = lean_nat_dec_le(x_584, x_2); +x_586 = l_Lean_Name_reprPrec(x_582, x_584); +x_587 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__62; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_586); +lean_ctor_set(x_1, 0, x_587); +x_588 = lean_box(1); +x_589 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_589, 0, x_1); +lean_ctor_set(x_589, 1, x_588); +x_590 = l_Lean_Name_reprPrec(x_583, x_584); +x_591 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_591, 0, x_589); +lean_ctor_set(x_591, 1, x_590); +if (x_585 == 0) +{ +lean_object* x_592; lean_object* x_593; uint8_t x_594; lean_object* x_595; lean_object* x_596; +x_592 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_593 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_593, 0, x_592); +lean_ctor_set(x_593, 1, x_591); +x_594 = 0; +x_595 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_595, 0, x_593); +lean_ctor_set_uint8(x_595, sizeof(void*)*1, x_594); +x_596 = l_Repr_addAppParen(x_595, x_2); +return x_596; +} +else +{ +lean_object* x_597; lean_object* x_598; uint8_t x_599; lean_object* x_600; lean_object* x_601; +x_597 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_598 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_598, 0, x_597); +lean_ctor_set(x_598, 1, x_591); +x_599 = 0; +x_600 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_600, 0, x_598); +lean_ctor_set_uint8(x_600, sizeof(void*)*1, x_599); +x_601 = l_Repr_addAppParen(x_600, x_2); +return x_601; +} +} +else +{ +lean_object* x_602; lean_object* x_603; lean_object* x_604; uint8_t 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; +x_602 = lean_ctor_get(x_1, 0); +x_603 = lean_ctor_get(x_1, 1); +lean_inc(x_603); +lean_inc(x_602); +lean_dec(x_1); +x_604 = lean_unsigned_to_nat(1024u); +x_605 = lean_nat_dec_le(x_604, x_2); +x_606 = l_Lean_Name_reprPrec(x_602, x_604); +x_607 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__62; +x_608 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_608, 0, x_607); +lean_ctor_set(x_608, 1, x_606); +x_609 = lean_box(1); +x_610 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_610, 0, x_608); +lean_ctor_set(x_610, 1, x_609); +x_611 = l_Lean_Name_reprPrec(x_603, x_604); +x_612 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_612, 0, x_610); +lean_ctor_set(x_612, 1, x_611); +if (x_605 == 0) +{ +lean_object* x_613; lean_object* x_614; uint8_t x_615; lean_object* x_616; lean_object* x_617; +x_613 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_614 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_614, 0, x_613); +lean_ctor_set(x_614, 1, x_612); +x_615 = 0; +x_616 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_616, 0, x_614); +lean_ctor_set_uint8(x_616, sizeof(void*)*1, x_615); +x_617 = l_Repr_addAppParen(x_616, x_2); +return x_617; +} +else +{ +lean_object* x_618; lean_object* x_619; uint8_t x_620; lean_object* x_621; lean_object* x_622; +x_618 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_619 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_619, 0, x_618); +lean_ctor_set(x_619, 1, x_612); +x_620 = 0; +x_621 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_621, 0, x_619); +lean_ctor_set_uint8(x_621, sizeof(void*)*1, x_620); +x_622 = l_Repr_addAppParen(x_621, x_2); +return x_622; +} +} +} +case 19: +{ +uint8_t x_623; +x_623 = !lean_is_exclusive(x_1); +if (x_623 == 0) +{ +lean_object* x_624; lean_object* x_625; uint8_t x_626; lean_object* x_627; lean_object* x_628; lean_object* x_629; +x_624 = lean_ctor_get(x_1, 0); +x_625 = lean_unsigned_to_nat(1024u); +x_626 = lean_nat_dec_le(x_625, x_2); +x_627 = l_String_quote(x_624); +lean_dec(x_624); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_627); +x_628 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__65; +x_629 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_629, 0, x_628); +lean_ctor_set(x_629, 1, x_1); +if (x_626 == 0) +{ +lean_object* x_630; lean_object* x_631; uint8_t x_632; lean_object* x_633; lean_object* x_634; +x_630 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_631 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_631, 0, x_630); +lean_ctor_set(x_631, 1, x_629); +x_632 = 0; +x_633 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_633, 0, x_631); +lean_ctor_set_uint8(x_633, sizeof(void*)*1, x_632); +x_634 = l_Repr_addAppParen(x_633, x_2); +return x_634; +} +else +{ +lean_object* x_635; lean_object* x_636; uint8_t x_637; lean_object* x_638; lean_object* x_639; +x_635 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_636 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_636, 0, x_635); +lean_ctor_set(x_636, 1, x_629); +x_637 = 0; +x_638 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_638, 0, x_636); +lean_ctor_set_uint8(x_638, sizeof(void*)*1, x_637); +x_639 = l_Repr_addAppParen(x_638, x_2); +return x_639; +} +} +else +{ +lean_object* x_640; lean_object* x_641; uint8_t x_642; lean_object* x_643; lean_object* x_644; lean_object* x_645; lean_object* x_646; +x_640 = lean_ctor_get(x_1, 0); +lean_inc(x_640); +lean_dec(x_1); +x_641 = lean_unsigned_to_nat(1024u); +x_642 = lean_nat_dec_le(x_641, x_2); +x_643 = l_String_quote(x_640); +lean_dec(x_640); +x_644 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_644, 0, x_643); +x_645 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__65; +x_646 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_646, 0, x_645); +lean_ctor_set(x_646, 1, x_644); +if (x_642 == 0) +{ +lean_object* x_647; lean_object* x_648; uint8_t x_649; lean_object* x_650; lean_object* x_651; +x_647 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_648 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_648, 0, x_647); +lean_ctor_set(x_648, 1, x_646); +x_649 = 0; +x_650 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_650, 0, x_648); +lean_ctor_set_uint8(x_650, sizeof(void*)*1, x_649); +x_651 = l_Repr_addAppParen(x_650, x_2); +return x_651; +} +else +{ +lean_object* x_652; lean_object* x_653; uint8_t x_654; lean_object* x_655; lean_object* x_656; +x_652 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_653 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_653, 0, x_652); +lean_ctor_set(x_653, 1, x_646); +x_654 = 0; +x_655 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_655, 0, x_653); +lean_ctor_set_uint8(x_655, sizeof(void*)*1, x_654); +x_656 = l_Repr_addAppParen(x_655, x_2); +return x_656; +} +} +} +case 20: +{ +uint8_t x_657; +x_657 = !lean_is_exclusive(x_1); +if (x_657 == 0) +{ +lean_object* x_658; lean_object* x_659; uint8_t x_660; lean_object* x_661; lean_object* x_662; lean_object* x_663; +x_658 = lean_ctor_get(x_1, 0); +x_659 = lean_unsigned_to_nat(1024u); +x_660 = lean_nat_dec_le(x_659, x_2); +x_661 = l_String_quote(x_658); +lean_dec(x_658); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_661); +x_662 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__68; +x_663 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_663, 0, x_662); +lean_ctor_set(x_663, 1, x_1); +if (x_660 == 0) +{ +lean_object* x_664; lean_object* x_665; uint8_t x_666; lean_object* x_667; lean_object* x_668; +x_664 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_665 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_665, 0, x_664); +lean_ctor_set(x_665, 1, x_663); +x_666 = 0; +x_667 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_667, 0, x_665); +lean_ctor_set_uint8(x_667, sizeof(void*)*1, x_666); +x_668 = l_Repr_addAppParen(x_667, x_2); +return x_668; +} +else +{ +lean_object* x_669; lean_object* x_670; uint8_t x_671; lean_object* x_672; lean_object* x_673; +x_669 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_670 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_670, 0, x_669); +lean_ctor_set(x_670, 1, x_663); +x_671 = 0; +x_672 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_672, 0, x_670); +lean_ctor_set_uint8(x_672, sizeof(void*)*1, x_671); +x_673 = l_Repr_addAppParen(x_672, x_2); +return x_673; +} +} +else +{ +lean_object* x_674; lean_object* x_675; uint8_t x_676; lean_object* x_677; lean_object* x_678; lean_object* x_679; lean_object* x_680; +x_674 = lean_ctor_get(x_1, 0); +lean_inc(x_674); +lean_dec(x_1); +x_675 = lean_unsigned_to_nat(1024u); +x_676 = lean_nat_dec_le(x_675, x_2); +x_677 = l_String_quote(x_674); +lean_dec(x_674); +x_678 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_678, 0, x_677); +x_679 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__68; +x_680 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_680, 0, x_679); +lean_ctor_set(x_680, 1, x_678); +if (x_676 == 0) +{ +lean_object* x_681; lean_object* x_682; uint8_t x_683; lean_object* x_684; lean_object* x_685; +x_681 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_682 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_682, 0, x_681); +lean_ctor_set(x_682, 1, x_680); +x_683 = 0; +x_684 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_684, 0, x_682); +lean_ctor_set_uint8(x_684, sizeof(void*)*1, x_683); +x_685 = l_Repr_addAppParen(x_684, x_2); +return x_685; +} +else +{ +lean_object* x_686; lean_object* x_687; uint8_t x_688; lean_object* x_689; lean_object* x_690; +x_686 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_687 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_687, 0, x_686); +lean_ctor_set(x_687, 1, x_680); +x_688 = 0; +x_689 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_689, 0, x_687); +lean_ctor_set_uint8(x_689, sizeof(void*)*1, x_688); +x_690 = l_Repr_addAppParen(x_689, x_2); +return x_690; +} +} +} +case 21: +{ +uint8_t x_691; +x_691 = !lean_is_exclusive(x_1); +if (x_691 == 0) +{ +lean_object* x_692; lean_object* x_693; uint8_t x_694; lean_object* x_695; lean_object* x_696; lean_object* x_697; +x_692 = lean_ctor_get(x_1, 0); +x_693 = lean_unsigned_to_nat(1024u); +x_694 = lean_nat_dec_le(x_693, x_2); +x_695 = l_String_quote(x_692); +lean_dec(x_692); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_695); +x_696 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__71; +x_697 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_697, 0, x_696); +lean_ctor_set(x_697, 1, x_1); +if (x_694 == 0) +{ +lean_object* x_698; lean_object* x_699; uint8_t x_700; lean_object* x_701; lean_object* x_702; +x_698 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_699 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_699, 0, x_698); +lean_ctor_set(x_699, 1, x_697); +x_700 = 0; +x_701 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_701, 0, x_699); +lean_ctor_set_uint8(x_701, sizeof(void*)*1, x_700); +x_702 = l_Repr_addAppParen(x_701, x_2); +return x_702; +} +else +{ +lean_object* x_703; lean_object* x_704; uint8_t x_705; lean_object* x_706; lean_object* x_707; +x_703 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_704 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_704, 0, x_703); +lean_ctor_set(x_704, 1, x_697); +x_705 = 0; +x_706 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_706, 0, x_704); +lean_ctor_set_uint8(x_706, sizeof(void*)*1, x_705); +x_707 = l_Repr_addAppParen(x_706, x_2); +return x_707; +} +} +else +{ +lean_object* x_708; lean_object* x_709; uint8_t x_710; lean_object* x_711; lean_object* x_712; lean_object* x_713; lean_object* x_714; +x_708 = lean_ctor_get(x_1, 0); +lean_inc(x_708); +lean_dec(x_1); +x_709 = lean_unsigned_to_nat(1024u); +x_710 = lean_nat_dec_le(x_709, x_2); +x_711 = l_String_quote(x_708); +lean_dec(x_708); +x_712 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_712, 0, x_711); +x_713 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__71; +x_714 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_714, 0, x_713); +lean_ctor_set(x_714, 1, x_712); +if (x_710 == 0) +{ +lean_object* x_715; lean_object* x_716; uint8_t x_717; lean_object* x_718; lean_object* x_719; +x_715 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_716 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_716, 0, x_715); +lean_ctor_set(x_716, 1, x_714); +x_717 = 0; +x_718 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_718, 0, x_716); +lean_ctor_set_uint8(x_718, sizeof(void*)*1, x_717); +x_719 = l_Repr_addAppParen(x_718, x_2); +return x_719; +} +else +{ +lean_object* x_720; lean_object* x_721; uint8_t x_722; lean_object* x_723; lean_object* x_724; +x_720 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_721 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_721, 0, x_720); +lean_ctor_set(x_721, 1, x_714); +x_722 = 0; +x_723 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_723, 0, x_721); +lean_ctor_set_uint8(x_723, sizeof(void*)*1, x_722); +x_724 = l_Repr_addAppParen(x_723, x_2); +return x_724; +} +} +} +case 22: +{ +uint8_t x_725; +x_725 = !lean_is_exclusive(x_1); +if (x_725 == 0) +{ +lean_object* x_726; lean_object* x_727; uint8_t x_728; lean_object* x_729; lean_object* x_730; lean_object* x_731; +x_726 = lean_ctor_get(x_1, 0); +x_727 = lean_unsigned_to_nat(1024u); +x_728 = lean_nat_dec_le(x_727, x_2); +x_729 = l_String_quote(x_726); +lean_dec(x_726); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_729); +x_730 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__74; +x_731 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_731, 0, x_730); +lean_ctor_set(x_731, 1, x_1); +if (x_728 == 0) +{ +lean_object* x_732; lean_object* x_733; uint8_t x_734; lean_object* x_735; lean_object* x_736; +x_732 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_733 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_733, 0, x_732); +lean_ctor_set(x_733, 1, x_731); +x_734 = 0; +x_735 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_735, 0, x_733); +lean_ctor_set_uint8(x_735, sizeof(void*)*1, x_734); +x_736 = l_Repr_addAppParen(x_735, x_2); +return x_736; +} +else +{ +lean_object* x_737; lean_object* x_738; uint8_t x_739; lean_object* x_740; lean_object* x_741; +x_737 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_738 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_738, 0, x_737); +lean_ctor_set(x_738, 1, x_731); +x_739 = 0; +x_740 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_740, 0, x_738); +lean_ctor_set_uint8(x_740, sizeof(void*)*1, x_739); +x_741 = l_Repr_addAppParen(x_740, x_2); +return x_741; +} +} +else +{ +lean_object* x_742; lean_object* x_743; uint8_t x_744; lean_object* x_745; lean_object* x_746; lean_object* x_747; lean_object* x_748; +x_742 = lean_ctor_get(x_1, 0); +lean_inc(x_742); +lean_dec(x_1); +x_743 = lean_unsigned_to_nat(1024u); +x_744 = lean_nat_dec_le(x_743, x_2); +x_745 = l_String_quote(x_742); +lean_dec(x_742); +x_746 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_746, 0, x_745); +x_747 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__74; +x_748 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_748, 0, x_747); +lean_ctor_set(x_748, 1, x_746); +if (x_744 == 0) +{ +lean_object* x_749; lean_object* x_750; uint8_t x_751; lean_object* x_752; lean_object* x_753; +x_749 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_750 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_750, 0, x_749); +lean_ctor_set(x_750, 1, x_748); +x_751 = 0; +x_752 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_752, 0, x_750); +lean_ctor_set_uint8(x_752, sizeof(void*)*1, x_751); +x_753 = l_Repr_addAppParen(x_752, x_2); +return x_753; +} +else +{ +lean_object* x_754; lean_object* x_755; uint8_t x_756; lean_object* x_757; lean_object* x_758; +x_754 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_755 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_755, 0, x_754); +lean_ctor_set(x_755, 1, x_748); +x_756 = 0; +x_757 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_757, 0, x_755); +lean_ctor_set_uint8(x_757, sizeof(void*)*1, x_756); +x_758 = l_Repr_addAppParen(x_757, x_2); +return x_758; +} +} +} +case 23: +{ +uint8_t x_759; +x_759 = !lean_is_exclusive(x_1); +if (x_759 == 0) +{ +lean_object* x_760; lean_object* x_761; uint8_t 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; +x_760 = lean_ctor_get(x_1, 0); +x_761 = lean_unsigned_to_nat(1024u); +x_762 = lean_nat_dec_le(x_761, x_2); +x_763 = l_String_quote(x_760); +lean_dec(x_760); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_763); +x_764 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__79; +x_765 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_765, 0, x_764); +lean_ctor_set(x_765, 1, x_1); +x_766 = l_Repr_addAppParen(x_765, x_761); +x_767 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__77; +x_768 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_768, 0, x_767); +lean_ctor_set(x_768, 1, x_766); +if (x_762 == 0) +{ +lean_object* x_769; lean_object* x_770; uint8_t x_771; lean_object* x_772; lean_object* x_773; +x_769 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_770 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_770, 0, x_769); +lean_ctor_set(x_770, 1, x_768); +x_771 = 0; +x_772 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_772, 0, x_770); +lean_ctor_set_uint8(x_772, sizeof(void*)*1, x_771); +x_773 = l_Repr_addAppParen(x_772, x_2); +return x_773; +} +else +{ +lean_object* x_774; lean_object* x_775; uint8_t x_776; lean_object* x_777; lean_object* x_778; +x_774 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_775 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_775, 0, x_774); +lean_ctor_set(x_775, 1, x_768); +x_776 = 0; +x_777 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_777, 0, x_775); +lean_ctor_set_uint8(x_777, sizeof(void*)*1, x_776); +x_778 = l_Repr_addAppParen(x_777, x_2); +return x_778; +} +} +else +{ +lean_object* x_779; lean_object* x_780; uint8_t 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; +x_779 = lean_ctor_get(x_1, 0); +lean_inc(x_779); +lean_dec(x_1); +x_780 = lean_unsigned_to_nat(1024u); +x_781 = lean_nat_dec_le(x_780, x_2); +x_782 = l_String_quote(x_779); +lean_dec(x_779); +x_783 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_783, 0, x_782); +x_784 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__79; +x_785 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_785, 0, x_784); +lean_ctor_set(x_785, 1, x_783); +x_786 = l_Repr_addAppParen(x_785, x_780); +x_787 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__77; +x_788 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_788, 0, x_787); +lean_ctor_set(x_788, 1, x_786); +if (x_781 == 0) +{ +lean_object* x_789; lean_object* x_790; uint8_t x_791; lean_object* x_792; lean_object* x_793; +x_789 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_790 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_790, 0, x_789); +lean_ctor_set(x_790, 1, x_788); +x_791 = 0; +x_792 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_792, 0, x_790); +lean_ctor_set_uint8(x_792, sizeof(void*)*1, x_791); +x_793 = l_Repr_addAppParen(x_792, x_2); +return x_793; +} +else +{ +lean_object* x_794; lean_object* x_795; uint8_t x_796; lean_object* x_797; lean_object* x_798; +x_794 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_795 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_795, 0, x_794); +lean_ctor_set(x_795, 1, x_788); +x_796 = 0; +x_797 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_797, 0, x_795); +lean_ctor_set_uint8(x_797, sizeof(void*)*1, x_796); +x_798 = l_Repr_addAppParen(x_797, x_2); +return x_798; +} +} +} +case 24: +{ +lean_object* x_799; uint8_t x_800; +x_799 = lean_unsigned_to_nat(1024u); +x_800 = lean_nat_dec_le(x_799, x_2); +if (x_800 == 0) +{ +lean_object* x_801; lean_object* x_802; +x_801 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__83; +x_802 = l_Repr_addAppParen(x_801, x_2); +return x_802; +} +else +{ +lean_object* x_803; lean_object* x_804; +x_803 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__85; +x_804 = l_Repr_addAppParen(x_803, x_2); +return x_804; +} +} +case 25: +{ +lean_object* x_805; uint8_t x_806; +x_805 = lean_unsigned_to_nat(1024u); +x_806 = lean_nat_dec_le(x_805, x_2); +if (x_806 == 0) +{ +lean_object* x_807; lean_object* x_808; +x_807 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__89; +x_808 = l_Repr_addAppParen(x_807, x_2); +return x_808; +} +else +{ +lean_object* x_809; lean_object* x_810; +x_809 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__91; +x_810 = l_Repr_addAppParen(x_809, x_2); +return x_810; +} +} +case 26: +{ +uint8_t x_811; +x_811 = !lean_is_exclusive(x_1); +if (x_811 == 0) +{ +lean_object* x_812; lean_object* x_813; lean_object* x_814; uint8_t 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; +x_812 = lean_ctor_get(x_1, 0); +x_813 = lean_ctor_get(x_1, 1); +x_814 = lean_unsigned_to_nat(1024u); +x_815 = lean_nat_dec_le(x_814, x_2); +x_816 = l_String_quote(x_812); +lean_dec(x_812); +x_817 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_817, 0, x_816); +x_818 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__94; +lean_ctor_set_tag(x_1, 5); +lean_ctor_set(x_1, 1, x_817); +lean_ctor_set(x_1, 0, x_818); +x_819 = lean_box(1); +x_820 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_820, 0, x_1); +lean_ctor_set(x_820, 1, x_819); +x_821 = l_String_quote(x_813); +lean_dec(x_813); +x_822 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_822, 0, x_821); +x_823 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_823, 0, x_820); +lean_ctor_set(x_823, 1, x_822); +if (x_815 == 0) +{ +lean_object* x_824; lean_object* x_825; uint8_t x_826; lean_object* x_827; lean_object* x_828; +x_824 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_825 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_825, 0, x_824); +lean_ctor_set(x_825, 1, x_823); +x_826 = 0; +x_827 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_827, 0, x_825); +lean_ctor_set_uint8(x_827, sizeof(void*)*1, x_826); +x_828 = l_Repr_addAppParen(x_827, x_2); +return x_828; +} +else +{ +lean_object* x_829; lean_object* x_830; uint8_t x_831; lean_object* x_832; lean_object* x_833; +x_829 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_830 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_830, 0, x_829); +lean_ctor_set(x_830, 1, x_823); +x_831 = 0; +x_832 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_832, 0, x_830); +lean_ctor_set_uint8(x_832, sizeof(void*)*1, x_831); +x_833 = l_Repr_addAppParen(x_832, x_2); +return x_833; +} +} +else +{ +lean_object* x_834; lean_object* x_835; lean_object* x_836; uint8_t x_837; lean_object* x_838; lean_object* x_839; lean_object* x_840; lean_object* x_841; lean_object* x_842; lean_object* x_843; lean_object* x_844; lean_object* x_845; lean_object* x_846; +x_834 = lean_ctor_get(x_1, 0); +x_835 = lean_ctor_get(x_1, 1); +lean_inc(x_835); +lean_inc(x_834); +lean_dec(x_1); +x_836 = lean_unsigned_to_nat(1024u); +x_837 = lean_nat_dec_le(x_836, x_2); +x_838 = l_String_quote(x_834); +lean_dec(x_834); +x_839 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_839, 0, x_838); +x_840 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__94; +x_841 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_841, 0, x_840); +lean_ctor_set(x_841, 1, x_839); +x_842 = lean_box(1); +x_843 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_843, 0, x_841); +lean_ctor_set(x_843, 1, x_842); +x_844 = l_String_quote(x_835); +lean_dec(x_835); +x_845 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_845, 0, x_844); +x_846 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_846, 0, x_843); +lean_ctor_set(x_846, 1, x_845); +if (x_837 == 0) +{ +lean_object* x_847; lean_object* x_848; uint8_t x_849; lean_object* x_850; lean_object* x_851; +x_847 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_848 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_848, 0, x_847); +lean_ctor_set(x_848, 1, x_846); +x_849 = 0; +x_850 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_850, 0, x_848); +lean_ctor_set_uint8(x_850, sizeof(void*)*1, x_849); +x_851 = l_Repr_addAppParen(x_850, x_2); +return x_851; +} +else +{ +lean_object* x_852; lean_object* x_853; uint8_t x_854; lean_object* x_855; lean_object* x_856; +x_852 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_853 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_853, 0, x_852); +lean_ctor_set(x_853, 1, x_846); +x_854 = 0; +x_855 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_855, 0, x_853); +lean_ctor_set_uint8(x_855, sizeof(void*)*1, x_854); +x_856 = l_Repr_addAppParen(x_855, x_2); +return x_856; +} +} +} +default: +{ +uint8_t x_857; +x_857 = !lean_is_exclusive(x_1); +if (x_857 == 0) +{ +lean_object* x_858; lean_object* x_859; uint8_t x_860; lean_object* x_861; lean_object* x_862; lean_object* x_863; +x_858 = lean_ctor_get(x_1, 0); +x_859 = lean_unsigned_to_nat(1024u); +x_860 = lean_nat_dec_le(x_859, x_2); +x_861 = l_String_quote(x_858); +lean_dec(x_858); +lean_ctor_set_tag(x_1, 3); +lean_ctor_set(x_1, 0, x_861); +x_862 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__97; +x_863 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_863, 0, x_862); +lean_ctor_set(x_863, 1, x_1); +if (x_860 == 0) +{ +lean_object* x_864; lean_object* x_865; uint8_t x_866; lean_object* x_867; lean_object* x_868; +x_864 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_865 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_865, 0, x_864); +lean_ctor_set(x_865, 1, x_863); +x_866 = 0; +x_867 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_867, 0, x_865); +lean_ctor_set_uint8(x_867, sizeof(void*)*1, x_866); +x_868 = l_Repr_addAppParen(x_867, x_2); +return x_868; +} +else +{ +lean_object* x_869; lean_object* x_870; uint8_t x_871; lean_object* x_872; lean_object* x_873; +x_869 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_870 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_870, 0, x_869); +lean_ctor_set(x_870, 1, x_863); +x_871 = 0; +x_872 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_872, 0, x_870); +lean_ctor_set_uint8(x_872, sizeof(void*)*1, x_871); +x_873 = l_Repr_addAppParen(x_872, x_2); +return x_873; +} +} +else +{ +lean_object* x_874; lean_object* x_875; uint8_t x_876; lean_object* x_877; lean_object* x_878; lean_object* x_879; lean_object* x_880; +x_874 = lean_ctor_get(x_1, 0); +lean_inc(x_874); +lean_dec(x_1); +x_875 = lean_unsigned_to_nat(1024u); +x_876 = lean_nat_dec_le(x_875, x_2); +x_877 = l_String_quote(x_874); +lean_dec(x_874); +x_878 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_878, 0, x_877); +x_879 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__97; +x_880 = lean_alloc_ctor(5, 2, 0); +lean_ctor_set(x_880, 0, x_879); +lean_ctor_set(x_880, 1, x_878); +if (x_876 == 0) +{ +lean_object* x_881; lean_object* x_882; uint8_t x_883; lean_object* x_884; lean_object* x_885; +x_881 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3; +x_882 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_882, 0, x_881); +lean_ctor_set(x_882, 1, x_880); +x_883 = 0; +x_884 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_884, 0, x_882); +lean_ctor_set_uint8(x_884, sizeof(void*)*1, x_883); +x_885 = l_Repr_addAppParen(x_884, x_2); +return x_885; +} +else +{ +lean_object* x_886; lean_object* x_887; uint8_t x_888; lean_object* x_889; lean_object* x_890; +x_886 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6; +x_887 = lean_alloc_ctor(4, 2, 0); +lean_ctor_set(x_887, 0, x_886); +lean_ctor_set(x_887, 1, x_880); +x_888 = 0; +x_889 = lean_alloc_ctor(6, 1, 1); +lean_ctor_set(x_889, 0, x_887); +lean_ctor_set_uint8(x_889, sizeof(void*)*1, x_888); +x_890 = l_Repr_addAppParen(x_889, x_2); +return x_890; +} +} +} +} +} +} +LEAN_EXPORT lean_object* l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____boxed(lean_object* x_1, lean_object* x_2) { +_start: +{ +lean_object* x_3; +x_3 = l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305_(x_1, x_2); +lean_dec(x_2); +return x_3; +} +} +static lean_object* _init_l_Lake_instReprCliError___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____boxed), 2, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_instReprCliError() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_instReprCliError___closed__1; +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("missing command", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__2() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown command '", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__3() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("'", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__4() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("missing ", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__5() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("", 0); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__6() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" after ", 7); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__7() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown short option '-", 23); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__8() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown long option '", 21); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__9() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" ", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__10() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unexpected arguments: ", 22); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__11() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown package template `", 26); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__12() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("`", 1); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__13() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown configuration language `", 32); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__14() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown module `", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__15() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown package `", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__16() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown ", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__17() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" facet `", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__18() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown target `", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__19() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("package '", 9); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__20() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' has no module '", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__21() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' has no target '", 17); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__22() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("target `", 8); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__23() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("` is not a buildable via `lake`", 31); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__24() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid script spec '", 21); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__25() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' (too many '", 13); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__26() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("')", 2); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__27() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("invalid facet `", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__28() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("`; target ", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__29() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(" has no facets", 14); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__30() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown executable ", 19); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__31() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("unknown script ", 15); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__32() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("no documentation provided for `", 31); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__33() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("' (too many '/')", 16); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__34() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("output configuration file already exists: ", 42); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__35() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("could not detect a Lean installation", 36); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__36() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("could not detect the configuration of the Lake installation", 59); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__37() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("expected Lean commit ", 21); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__38() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes(", but got ", 10); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_toString___closed__39() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("nothing", 7); +return x_1; +} +} +LEAN_EXPORT lean_object* l_Lake_CliError_toString(lean_object* x_1) { +_start: +{ +switch (lean_obj_tag(x_1)) { +case 0: +{ +lean_object* x_2; +x_2 = l_Lake_CliError_toString___closed__1; +return x_2; +} +case 1: +{ +lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; +x_3 = lean_ctor_get(x_1, 0); +lean_inc(x_3); +lean_dec(x_1); +x_4 = l_Lake_CliError_toString___closed__2; +x_5 = lean_string_append(x_4, x_3); +lean_dec(x_3); +x_6 = l_Lake_CliError_toString___closed__3; +x_7 = lean_string_append(x_5, x_6); +return x_7; +} +case 2: +{ +lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; +x_8 = lean_ctor_get(x_1, 0); +lean_inc(x_8); +lean_dec(x_1); +x_9 = l_Lake_CliError_toString___closed__4; +x_10 = lean_string_append(x_9, x_8); +lean_dec(x_8); +x_11 = l_Lake_CliError_toString___closed__5; +x_12 = lean_string_append(x_10, x_11); +return x_12; +} +case 3: +{ +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_13 = lean_ctor_get(x_1, 0); +lean_inc(x_13); +x_14 = lean_ctor_get(x_1, 1); +lean_inc(x_14); +lean_dec(x_1); +x_15 = l_Lake_CliError_toString___closed__4; +x_16 = lean_string_append(x_15, x_14); +lean_dec(x_14); +x_17 = l_Lake_CliError_toString___closed__6; +x_18 = lean_string_append(x_16, x_17); +x_19 = lean_string_append(x_18, x_13); +lean_dec(x_13); +x_20 = l_Lake_CliError_toString___closed__5; +x_21 = lean_string_append(x_19, x_20); +return x_21; +} +case 4: +{ +lean_object* x_22; lean_object* x_23; uint32_t x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_22 = lean_ctor_get(x_1, 0); +lean_inc(x_22); +lean_dec(x_1); +x_23 = l_Lake_CliError_toString___closed__5; +x_24 = lean_unbox_uint32(x_22); +lean_dec(x_22); +x_25 = lean_string_push(x_23, x_24); +x_26 = l_Lake_CliError_toString___closed__7; +x_27 = lean_string_append(x_26, x_25); +lean_dec(x_25); +x_28 = l_Lake_CliError_toString___closed__3; +x_29 = lean_string_append(x_27, x_28); +return x_29; +} +case 5: +{ +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_30 = lean_ctor_get(x_1, 0); +lean_inc(x_30); +lean_dec(x_1); +x_31 = l_Lake_CliError_toString___closed__8; +x_32 = lean_string_append(x_31, x_30); +lean_dec(x_30); +x_33 = l_Lake_CliError_toString___closed__3; +x_34 = lean_string_append(x_32, x_33); +return x_34; +} +case 6: +{ +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_35 = lean_ctor_get(x_1, 0); +lean_inc(x_35); +lean_dec(x_1); +x_36 = l_Lake_CliError_toString___closed__9; +x_37 = l_String_intercalate(x_36, x_35); +x_38 = l_Lake_CliError_toString___closed__10; +x_39 = lean_string_append(x_38, x_37); +lean_dec(x_37); +x_40 = l_Lake_CliError_toString___closed__5; +x_41 = lean_string_append(x_39, x_40); +return x_41; +} +case 7: +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_42 = lean_ctor_get(x_1, 0); +lean_inc(x_42); +lean_dec(x_1); +x_43 = l_Lake_CliError_toString___closed__11; +x_44 = lean_string_append(x_43, x_42); +lean_dec(x_42); +x_45 = l_Lake_CliError_toString___closed__12; +x_46 = lean_string_append(x_44, x_45); +return x_46; +} +case 8: +{ +lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_47 = lean_ctor_get(x_1, 0); +lean_inc(x_47); +lean_dec(x_1); +x_48 = l_Lake_CliError_toString___closed__13; +x_49 = lean_string_append(x_48, x_47); +lean_dec(x_47); +x_50 = l_Lake_CliError_toString___closed__12; +x_51 = lean_string_append(x_49, x_50); +return x_51; +} +case 9: +{ +lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_52 = lean_ctor_get(x_1, 0); +lean_inc(x_52); +lean_dec(x_1); +x_53 = 0; +x_54 = l_Lean_Name_toString(x_52, x_53); +x_55 = l_Lake_CliError_toString___closed__14; +x_56 = lean_string_append(x_55, x_54); +lean_dec(x_54); +x_57 = l_Lake_CliError_toString___closed__12; +x_58 = lean_string_append(x_56, x_57); +return x_58; +} +case 10: +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_59 = lean_ctor_get(x_1, 0); +lean_inc(x_59); +lean_dec(x_1); +x_60 = l_Lake_CliError_toString___closed__15; +x_61 = lean_string_append(x_60, x_59); +lean_dec(x_59); +x_62 = l_Lake_CliError_toString___closed__12; +x_63 = lean_string_append(x_61, x_62); +return x_63; +} +case 11: +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_64 = lean_ctor_get(x_1, 0); +lean_inc(x_64); +x_65 = lean_ctor_get(x_1, 1); +lean_inc(x_65); +lean_dec(x_1); +x_66 = l_Lake_CliError_toString___closed__16; +x_67 = lean_string_append(x_66, x_64); +lean_dec(x_64); +x_68 = l_Lake_CliError_toString___closed__17; +x_69 = lean_string_append(x_67, x_68); +x_70 = 0; +x_71 = l_Lean_Name_toString(x_65, x_70); +x_72 = lean_string_append(x_69, x_71); +lean_dec(x_71); +x_73 = l_Lake_CliError_toString___closed__12; +x_74 = lean_string_append(x_72, x_73); +return x_74; +} +case 12: +{ +lean_object* x_75; uint8_t x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_75 = lean_ctor_get(x_1, 0); +lean_inc(x_75); +lean_dec(x_1); +x_76 = 0; +x_77 = l_Lean_Name_toString(x_75, x_76); +x_78 = l_Lake_CliError_toString___closed__18; +x_79 = lean_string_append(x_78, x_77); +lean_dec(x_77); +x_80 = l_Lake_CliError_toString___closed__12; +x_81 = lean_string_append(x_79, x_80); +return x_81; +} +case 13: +{ +lean_object* x_82; lean_object* x_83; uint8_t x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_82 = lean_ctor_get(x_1, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_1, 1); +lean_inc(x_83); +lean_dec(x_1); +x_84 = 0; +x_85 = l_Lean_Name_toString(x_82, x_84); +x_86 = l_Lake_CliError_toString___closed__19; +x_87 = lean_string_append(x_86, x_85); +lean_dec(x_85); +x_88 = l_Lake_CliError_toString___closed__20; +x_89 = lean_string_append(x_87, x_88); +x_90 = l_Lean_Name_toString(x_83, x_84); +x_91 = lean_string_append(x_89, x_90); +lean_dec(x_90); +x_92 = l_Lake_CliError_toString___closed__3; +x_93 = lean_string_append(x_91, x_92); +return x_93; +} +case 14: +{ +lean_object* x_94; lean_object* x_95; uint8_t 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; +x_94 = lean_ctor_get(x_1, 0); +lean_inc(x_94); +x_95 = lean_ctor_get(x_1, 1); +lean_inc(x_95); +lean_dec(x_1); +x_96 = 0; +x_97 = l_Lean_Name_toString(x_94, x_96); +x_98 = l_Lake_CliError_toString___closed__19; +x_99 = lean_string_append(x_98, x_97); +lean_dec(x_97); +x_100 = l_Lake_CliError_toString___closed__21; +x_101 = lean_string_append(x_99, x_100); +x_102 = lean_string_append(x_101, x_95); +lean_dec(x_95); +x_103 = l_Lake_CliError_toString___closed__3; +x_104 = lean_string_append(x_102, x_103); +return x_104; +} +case 15: +{ +lean_object* x_105; uint8_t x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +x_105 = lean_ctor_get(x_1, 0); +lean_inc(x_105); +lean_dec(x_1); +x_106 = 0; +x_107 = l_Lean_Name_toString(x_105, x_106); +x_108 = l_Lake_CliError_toString___closed__22; +x_109 = lean_string_append(x_108, x_107); +lean_dec(x_107); +x_110 = l_Lake_CliError_toString___closed__23; +x_111 = lean_string_append(x_109, x_110); +return x_111; +} +case 16: +{ +lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; +x_112 = lean_ctor_get(x_1, 0); +lean_inc(x_112); +x_113 = lean_ctor_get(x_1, 1); +lean_inc(x_113); +lean_dec(x_1); +x_114 = l_Lake_CliError_toString___closed__5; +x_115 = lean_string_append(x_114, x_112); +lean_dec(x_112); +x_116 = l_Lake_CliError_toString___closed__17; +x_117 = lean_string_append(x_115, x_116); +x_118 = 0; +x_119 = l_Lean_Name_toString(x_113, x_118); +x_120 = lean_string_append(x_117, x_119); +lean_dec(x_119); +x_121 = l_Lake_CliError_toString___closed__23; +x_122 = lean_string_append(x_120, x_121); +return x_122; +} +case 17: +{ +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; uint32_t x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_123 = lean_ctor_get(x_1, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_1, 1); +lean_inc(x_124); +lean_dec(x_1); +x_125 = l_Lake_CliError_toString___closed__24; +x_126 = lean_string_append(x_125, x_123); +lean_dec(x_123); +x_127 = l_Lake_CliError_toString___closed__25; +x_128 = lean_string_append(x_126, x_127); +x_129 = l_Lake_CliError_toString___closed__5; +x_130 = lean_unbox_uint32(x_124); +lean_dec(x_124); +x_131 = lean_string_push(x_129, x_130); +x_132 = lean_string_append(x_128, x_131); +lean_dec(x_131); +x_133 = l_Lake_CliError_toString___closed__26; +x_134 = lean_string_append(x_132, x_133); +return x_134; +} +case 18: +{ +lean_object* x_135; lean_object* x_136; uint8_t x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; +x_135 = lean_ctor_get(x_1, 0); +lean_inc(x_135); +x_136 = lean_ctor_get(x_1, 1); +lean_inc(x_136); +lean_dec(x_1); +x_137 = 0; +x_138 = l_Lean_Name_toString(x_136, x_137); +x_139 = l_Lake_CliError_toString___closed__27; +x_140 = lean_string_append(x_139, x_138); +lean_dec(x_138); +x_141 = l_Lake_CliError_toString___closed__28; +x_142 = lean_string_append(x_140, x_141); +x_143 = l_Lean_Name_toString(x_135, x_137); +x_144 = lean_string_append(x_142, x_143); +lean_dec(x_143); +x_145 = l_Lake_CliError_toString___closed__29; +x_146 = lean_string_append(x_144, x_145); +return x_146; +} +case 19: +{ +lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_147 = lean_ctor_get(x_1, 0); +lean_inc(x_147); +lean_dec(x_1); +x_148 = l_Lake_CliError_toString___closed__30; +x_149 = lean_string_append(x_148, x_147); +lean_dec(x_147); +x_150 = l_Lake_CliError_toString___closed__5; +x_151 = lean_string_append(x_149, x_150); +return x_151; +} +case 20: +{ +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_1, 0); +lean_inc(x_152); +lean_dec(x_1); +x_153 = l_Lake_CliError_toString___closed__31; +x_154 = lean_string_append(x_153, x_152); +lean_dec(x_152); +x_155 = l_Lake_CliError_toString___closed__5; +x_156 = lean_string_append(x_154, x_155); +return x_156; +} +case 21: +{ +lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; +x_157 = lean_ctor_get(x_1, 0); +lean_inc(x_157); +lean_dec(x_1); +x_158 = l_Lake_CliError_toString___closed__32; +x_159 = lean_string_append(x_158, x_157); +lean_dec(x_157); +x_160 = l_Lake_CliError_toString___closed__12; +x_161 = lean_string_append(x_159, x_160); +return x_161; +} +case 22: +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; +x_162 = lean_ctor_get(x_1, 0); +lean_inc(x_162); +lean_dec(x_1); +x_163 = l_Lake_CliError_toString___closed__24; +x_164 = lean_string_append(x_163, x_162); +lean_dec(x_162); +x_165 = l_Lake_CliError_toString___closed__33; +x_166 = lean_string_append(x_164, x_165); +return x_166; +} +case 23: +{ +lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; +x_167 = lean_ctor_get(x_1, 0); +lean_inc(x_167); +lean_dec(x_1); +x_168 = l_Lake_CliError_toString___closed__34; +x_169 = lean_string_append(x_168, x_167); +lean_dec(x_167); +x_170 = l_Lake_CliError_toString___closed__5; +x_171 = lean_string_append(x_169, x_170); +return x_171; +} +case 24: +{ +lean_object* x_172; +x_172 = l_Lake_CliError_toString___closed__35; +return x_172; +} +case 25: +{ +lean_object* x_173; +x_173 = l_Lake_CliError_toString___closed__36; +return x_173; +} +case 26: +{ +lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; uint8_t x_180; +x_174 = lean_ctor_get(x_1, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_1, 1); +lean_inc(x_175); +lean_dec(x_1); +x_176 = l_Lake_CliError_toString___closed__37; +x_177 = lean_string_append(x_176, x_174); +lean_dec(x_174); +x_178 = l_Lake_CliError_toString___closed__38; +x_179 = lean_string_append(x_177, x_178); +x_180 = l_String_isEmpty(x_175); +if (x_180 == 0) +{ +lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_181 = lean_string_append(x_179, x_175); +lean_dec(x_175); +x_182 = l_Lake_CliError_toString___closed__5; +x_183 = lean_string_append(x_181, x_182); +return x_183; +} +else +{ +lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; +lean_dec(x_175); +x_184 = l_Lake_CliError_toString___closed__39; +x_185 = lean_string_append(x_179, x_184); +x_186 = l_Lake_CliError_toString___closed__5; +x_187 = lean_string_append(x_185, x_186); +return x_187; +} +} +default: +{ +lean_object* x_188; +x_188 = lean_ctor_get(x_1, 0); +lean_inc(x_188); +lean_dec(x_1); +return x_188; +} +} +} +} +static lean_object* _init_l_Lake_CliError_instToString___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_alloc_closure((void*)(l_Lake_CliError_toString), 1, 0); +return x_1; +} +} +static lean_object* _init_l_Lake_CliError_instToString() { +_start: +{ +lean_object* x_1; +x_1 = l_Lake_CliError_instToString___closed__1; +return x_1; +} +} +lean_object* initialize_Init(uint8_t builtin, lean_object*); +static bool _G_initialized = false; +LEAN_EXPORT lean_object* initialize_Lake_CLI_Error(uint8_t builtin, lean_object* w) { +lean_object * res; +if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); +_G_initialized = true; +res = initialize_Init(builtin, lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +l_Lake_instInhabitedCliError = _init_l_Lake_instInhabitedCliError(); +lean_mark_persistent(l_Lake_instInhabitedCliError); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__1 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__1(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__1); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__2 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__2(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__2); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__3); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__4 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__4(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__4); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__5 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__5(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__5); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__6); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__7 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__7(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__7); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__8 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__8(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__8); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__9 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__9(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__9); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__10 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__10(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__10); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__11 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__11(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__11); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__12 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__12(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__12); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__13 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__13(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__13); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__14 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__14(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__14); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__15 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__15(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__15); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__16 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__16(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__16); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__17 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__17(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__17); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__18 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__18(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__18); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__19 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__19(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__19); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__20 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__20(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__20); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__21 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__21(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__21); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__22 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__22(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__22); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__23 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__23(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__23); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__24 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__24(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__24); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__25 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__25(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__25); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__26 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__26(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__26); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__27 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__27(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__27); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__28 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__28(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__28); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__29 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__29(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__29); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__30 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__30(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__30); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__31 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__31(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__31); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__32 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__32(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__32); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__33 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__33(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__33); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__34 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__34(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__34); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__35 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__35(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__35); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__36 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__36(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__36); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__37 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__37(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__37); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__38 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__38(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__38); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__39 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__39(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__39); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__40 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__40(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__40); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__41 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__41(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__41); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__42 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__42(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__42); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__43 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__43(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__43); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__44 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__44(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__44); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__45 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__45(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__45); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__46 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__46(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__46); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__47 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__47(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__47); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__48 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__48(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__48); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__49 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__49(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__49); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__50 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__50(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__50); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__51 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__51(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__51); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__52 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__52(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__52); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__53 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__53(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__53); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__54 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__54(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__54); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__55 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__55(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__55); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__56 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__56(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__56); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__57 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__57(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__57); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__58 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__58(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__58); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__59 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__59(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__59); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__60 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__60(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__60); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__61 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__61(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__61); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__62 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__62(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__62); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__63 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__63(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__63); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__64 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__64(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__64); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__65 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__65(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__65); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__66 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__66(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__66); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__67 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__67(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__67); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__68 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__68(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__68); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__69 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__69(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__69); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__70 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__70(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__70); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__71 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__71(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__71); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__72 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__72(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__72); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__73 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__73(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__73); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__74 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__74(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__74); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__75 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__75(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__75); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__76 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__76(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__76); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__77 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__77(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__77); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__78 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__78(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__78); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__79 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__79(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__79); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__80 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__80(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__80); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__81 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__81(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__81); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__82 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__82(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__82); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__83 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__83(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__83); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__84 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__84(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__84); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__85 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__85(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__85); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__86 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__86(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__86); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__87 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__87(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__87); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__88 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__88(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__88); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__89 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__89(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__89); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__90 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__90(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__90); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__91 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__91(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__91); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__92 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__92(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__92); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__93 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__93(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__93); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__94 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__94(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__94); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__95 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__95(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__95); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__96 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__96(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__96); +l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__97 = _init_l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__97(); +lean_mark_persistent(l___private_Lake_CLI_Error_0__Lake_reprCliError____x40_Lake_CLI_Error___hyg_305____closed__97); +l_Lake_instReprCliError___closed__1 = _init_l_Lake_instReprCliError___closed__1(); +lean_mark_persistent(l_Lake_instReprCliError___closed__1); +l_Lake_instReprCliError = _init_l_Lake_instReprCliError(); +lean_mark_persistent(l_Lake_instReprCliError); +l_Lake_CliError_toString___closed__1 = _init_l_Lake_CliError_toString___closed__1(); +lean_mark_persistent(l_Lake_CliError_toString___closed__1); +l_Lake_CliError_toString___closed__2 = _init_l_Lake_CliError_toString___closed__2(); +lean_mark_persistent(l_Lake_CliError_toString___closed__2); +l_Lake_CliError_toString___closed__3 = _init_l_Lake_CliError_toString___closed__3(); +lean_mark_persistent(l_Lake_CliError_toString___closed__3); +l_Lake_CliError_toString___closed__4 = _init_l_Lake_CliError_toString___closed__4(); +lean_mark_persistent(l_Lake_CliError_toString___closed__4); +l_Lake_CliError_toString___closed__5 = _init_l_Lake_CliError_toString___closed__5(); +lean_mark_persistent(l_Lake_CliError_toString___closed__5); +l_Lake_CliError_toString___closed__6 = _init_l_Lake_CliError_toString___closed__6(); +lean_mark_persistent(l_Lake_CliError_toString___closed__6); +l_Lake_CliError_toString___closed__7 = _init_l_Lake_CliError_toString___closed__7(); +lean_mark_persistent(l_Lake_CliError_toString___closed__7); +l_Lake_CliError_toString___closed__8 = _init_l_Lake_CliError_toString___closed__8(); +lean_mark_persistent(l_Lake_CliError_toString___closed__8); +l_Lake_CliError_toString___closed__9 = _init_l_Lake_CliError_toString___closed__9(); +lean_mark_persistent(l_Lake_CliError_toString___closed__9); +l_Lake_CliError_toString___closed__10 = _init_l_Lake_CliError_toString___closed__10(); +lean_mark_persistent(l_Lake_CliError_toString___closed__10); +l_Lake_CliError_toString___closed__11 = _init_l_Lake_CliError_toString___closed__11(); +lean_mark_persistent(l_Lake_CliError_toString___closed__11); +l_Lake_CliError_toString___closed__12 = _init_l_Lake_CliError_toString___closed__12(); +lean_mark_persistent(l_Lake_CliError_toString___closed__12); +l_Lake_CliError_toString___closed__13 = _init_l_Lake_CliError_toString___closed__13(); +lean_mark_persistent(l_Lake_CliError_toString___closed__13); +l_Lake_CliError_toString___closed__14 = _init_l_Lake_CliError_toString___closed__14(); +lean_mark_persistent(l_Lake_CliError_toString___closed__14); +l_Lake_CliError_toString___closed__15 = _init_l_Lake_CliError_toString___closed__15(); +lean_mark_persistent(l_Lake_CliError_toString___closed__15); +l_Lake_CliError_toString___closed__16 = _init_l_Lake_CliError_toString___closed__16(); +lean_mark_persistent(l_Lake_CliError_toString___closed__16); +l_Lake_CliError_toString___closed__17 = _init_l_Lake_CliError_toString___closed__17(); +lean_mark_persistent(l_Lake_CliError_toString___closed__17); +l_Lake_CliError_toString___closed__18 = _init_l_Lake_CliError_toString___closed__18(); +lean_mark_persistent(l_Lake_CliError_toString___closed__18); +l_Lake_CliError_toString___closed__19 = _init_l_Lake_CliError_toString___closed__19(); +lean_mark_persistent(l_Lake_CliError_toString___closed__19); +l_Lake_CliError_toString___closed__20 = _init_l_Lake_CliError_toString___closed__20(); +lean_mark_persistent(l_Lake_CliError_toString___closed__20); +l_Lake_CliError_toString___closed__21 = _init_l_Lake_CliError_toString___closed__21(); +lean_mark_persistent(l_Lake_CliError_toString___closed__21); +l_Lake_CliError_toString___closed__22 = _init_l_Lake_CliError_toString___closed__22(); +lean_mark_persistent(l_Lake_CliError_toString___closed__22); +l_Lake_CliError_toString___closed__23 = _init_l_Lake_CliError_toString___closed__23(); +lean_mark_persistent(l_Lake_CliError_toString___closed__23); +l_Lake_CliError_toString___closed__24 = _init_l_Lake_CliError_toString___closed__24(); +lean_mark_persistent(l_Lake_CliError_toString___closed__24); +l_Lake_CliError_toString___closed__25 = _init_l_Lake_CliError_toString___closed__25(); +lean_mark_persistent(l_Lake_CliError_toString___closed__25); +l_Lake_CliError_toString___closed__26 = _init_l_Lake_CliError_toString___closed__26(); +lean_mark_persistent(l_Lake_CliError_toString___closed__26); +l_Lake_CliError_toString___closed__27 = _init_l_Lake_CliError_toString___closed__27(); +lean_mark_persistent(l_Lake_CliError_toString___closed__27); +l_Lake_CliError_toString___closed__28 = _init_l_Lake_CliError_toString___closed__28(); +lean_mark_persistent(l_Lake_CliError_toString___closed__28); +l_Lake_CliError_toString___closed__29 = _init_l_Lake_CliError_toString___closed__29(); +lean_mark_persistent(l_Lake_CliError_toString___closed__29); +l_Lake_CliError_toString___closed__30 = _init_l_Lake_CliError_toString___closed__30(); +lean_mark_persistent(l_Lake_CliError_toString___closed__30); +l_Lake_CliError_toString___closed__31 = _init_l_Lake_CliError_toString___closed__31(); +lean_mark_persistent(l_Lake_CliError_toString___closed__31); +l_Lake_CliError_toString___closed__32 = _init_l_Lake_CliError_toString___closed__32(); +lean_mark_persistent(l_Lake_CliError_toString___closed__32); +l_Lake_CliError_toString___closed__33 = _init_l_Lake_CliError_toString___closed__33(); +lean_mark_persistent(l_Lake_CliError_toString___closed__33); +l_Lake_CliError_toString___closed__34 = _init_l_Lake_CliError_toString___closed__34(); +lean_mark_persistent(l_Lake_CliError_toString___closed__34); +l_Lake_CliError_toString___closed__35 = _init_l_Lake_CliError_toString___closed__35(); +lean_mark_persistent(l_Lake_CliError_toString___closed__35); +l_Lake_CliError_toString___closed__36 = _init_l_Lake_CliError_toString___closed__36(); +lean_mark_persistent(l_Lake_CliError_toString___closed__36); +l_Lake_CliError_toString___closed__37 = _init_l_Lake_CliError_toString___closed__37(); +lean_mark_persistent(l_Lake_CliError_toString___closed__37); +l_Lake_CliError_toString___closed__38 = _init_l_Lake_CliError_toString___closed__38(); +lean_mark_persistent(l_Lake_CliError_toString___closed__38); +l_Lake_CliError_toString___closed__39 = _init_l_Lake_CliError_toString___closed__39(); +lean_mark_persistent(l_Lake_CliError_toString___closed__39); +l_Lake_CliError_instToString___closed__1 = _init_l_Lake_CliError_instToString___closed__1(); +lean_mark_persistent(l_Lake_CliError_instToString___closed__1); +l_Lake_CliError_instToString = _init_l_Lake_CliError_instToString(); +lean_mark_persistent(l_Lake_CliError_instToString); +return lean_io_result_mk_ok(lean_box(0)); +} +#ifdef __cplusplus +} +#endif diff --git a/stage0/stdlib/Lake/CLI/Help.c b/stage0/stdlib/Lake/CLI/Help.c new file mode 100644 index 0000000000..1d167b9026 --- /dev/null +++ b/stage0/stdlib/Lake/CLI/Help.c @@ -0,0 +1,1231 @@ +// Lean compiler output +// Module: Lake.CLI.Help +// Imports: Init Lake.Version +#include +#if defined(__clang__) +#pragma clang diagnostic ignored "-Wunused-parameter" +#pragma clang diagnostic ignored "-Wunused-label" +#elif defined(__GNUC__) && !defined(__CLANG__) +#pragma GCC diagnostic ignored "-Wunused-parameter" +#pragma GCC diagnostic ignored "-Wunused-label" +#pragma GCC diagnostic ignored "-Wunused-but-set-variable" +#endif +#ifdef __cplusplus +extern "C" { +#endif +static lean_object* l_Lake_help___closed__18; +static lean_object* l_Lake_help___closed__2; +static lean_object* l_Lake_helpInit___closed__1; +static lean_object* l_Lake_helpClean___closed__1; +static lean_object* l_Lake_helpServe___closed__1; +static lean_object* l_Lake_help___closed__3; +LEAN_EXPORT lean_object* l_Lake_helpPack; +LEAN_EXPORT lean_object* l_Lake_help(lean_object*); +static lean_object* l_Lake_helpInit___closed__3; +static lean_object* l_Lake_help___closed__17; +LEAN_EXPORT lean_object* l_Lake_helpEnv; +LEAN_EXPORT lean_object* l_Lake_helpLint; +LEAN_EXPORT lean_object* l_Lake_helpCheckTest; +static lean_object* l_Lake_helpScript___closed__3; +static lean_object* l_Lake_help___closed__16; +uint8_t lean_string_dec_eq(lean_object*, lean_object*); +static lean_object* l_Lake_help___closed__1; +LEAN_EXPORT lean_object* l_Lake_helpCheckLint; +LEAN_EXPORT lean_object* l_Lake_helpBuild; +static lean_object* l_Lake_helpScript___closed__1; +static lean_object* l_Lake_helpUpdate___closed__1; +static lean_object* l_Lake_help___closed__13; +LEAN_EXPORT lean_object* l_Lake_usage; +LEAN_EXPORT lean_object* l_Lake_help___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lake_helpScript(lean_object*); +static lean_object* l_Lake_help___closed__8; +LEAN_EXPORT lean_object* l_Lake_helpScriptRun; +LEAN_EXPORT lean_object* l_Lake_helpTest; +static lean_object* l_Lake_helpNew___closed__1; +LEAN_EXPORT lean_object* l_Lake_helpUpload; +static lean_object* l_Lake_helpLint___closed__1; +static lean_object* l_Lake_help___closed__20; +LEAN_EXPORT lean_object* l_Lake_helpTranslateConfig; +LEAN_EXPORT lean_object* l_Lake_helpServe; +static lean_object* l_Lake_helpInit___closed__2; +static lean_object* l_Lake_helpPack___closed__1; +static lean_object* l_Lake_helpScriptDoc___closed__1; +static lean_object* l_Lake_help___closed__4; +static lean_object* l_Lake_helpCheckTest___closed__1; +static lean_object* l_Lake_help___closed__15; +static lean_object* l_Lake_help___closed__10; +static lean_object* l_Lake_helpInit___closed__4; +static lean_object* l_Lake_help___closed__21; +static lean_object* l_Lake_helpLean___closed__1; +static lean_object* l_Lake_helpTranslateConfig___closed__1; +static lean_object* l_Lake_helpBuild___closed__1; +static lean_object* l_Lake_helpExe___closed__1; +LEAN_EXPORT lean_object* l_Lake_helpLean; +static lean_object* l_Lake_help___closed__9; +static lean_object* l_Lake_helpUnpack___closed__1; +static lean_object* l_Lake_help___closed__7; +LEAN_EXPORT lean_object* l_Lake_helpScriptDoc; +static lean_object* l_Lake_helpTest___closed__1; +static lean_object* l_Lake_help___closed__12; +static lean_object* l_Lake_helpNew___closed__4; +LEAN_EXPORT lean_object* l_Lake_helpNew; +static lean_object* l_Lake_helpScriptRun___closed__1; +LEAN_EXPORT lean_object* l_Lake_helpExe; +LEAN_EXPORT lean_object* l_Lake_helpScriptList; +static lean_object* l_Lake_helpEnv___closed__1; +LEAN_EXPORT lean_object* l_Lake_helpInit; +static lean_object* l_Lake_helpNew___closed__2; +LEAN_EXPORT lean_object* l_Lake_helpUnpack; +LEAN_EXPORT lean_object* l_Lake_helpUpdate; +LEAN_EXPORT lean_object* l_Lake_helpScript___boxed(lean_object*); +static lean_object* l_Lake_helpScript___closed__2; +static lean_object* l_Lake_help___closed__5; +static lean_object* l_Lake_helpCheckLint___closed__1; +static lean_object* l_Lake_helpNew___closed__3; +static lean_object* l_Lake_templateHelp___closed__1; +static lean_object* l_Lake_helpUpload___closed__1; +static lean_object* l_Lake_helpScriptList___closed__1; +static lean_object* l_Lake_usage___closed__2; +static lean_object* l_Lake_help___closed__14; +lean_object* lean_string_append(lean_object*, lean_object*); +static lean_object* l_Lake_help___closed__11; +static lean_object* l_Lake_help___closed__6; +static lean_object* l_Lake_helpScriptCli___closed__1; +LEAN_EXPORT lean_object* l_Lake_templateHelp; +static lean_object* l_Lake_help___closed__19; +static lean_object* l_Lake_usage___closed__1; +LEAN_EXPORT lean_object* l_Lake_helpClean; +extern lean_object* l_Lake_uiVersionString; +LEAN_EXPORT lean_object* l_Lake_helpScriptCli; +static lean_object* _init_l_Lake_usage___closed__1() { +_start: +{ +lean_object* x_1; +x_1 = lean_mk_string_from_bytes("\n\nUSAGE:\n lake [OPTIONS] \n\nCOMMANDS:\n new create a Lean package in a new directory\n init create a Lean package in the current directory\n build ... build targets\n exe ... build an exe and run it in Lake's environment\n test test the package using the configured test driver\n check-test check if there is a properly configured test driver\n lint lint the package using the configured lint driver\n check-lint check if there is a properly configured lint driver\n clean remove build outputs\n env ... execute a command in Lake's environment\n lean elaborate a Lean file in Lake's context\n update update dependencies and save them to the manifest\n pack pack build artifacts into an archive for distribution\n unpack unpack build artifacts from an distributed archive\n upload upload build artifacts to a GitHub release\n script manage and run workspace scripts\n scripts shorthand for `lake script list`\n run